agora inbox for [email protected]
help / color / mirror / Atom feed[PATCH v1 2/5] Allow placing shared memory mapping with an offset
163+ messages / 2 participants
[nested] [flat]
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v1 2/5] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 065a5b63ac..7e6c8bb78d 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping slots */
static int next_free_slot = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_slot), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_slot] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "slot[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_slot), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--ers4zrhjqnhlajas
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v1-0003-Introduce-multiple-shmem-slots-for-shared-buffers.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH v2 2/6] Allow placing shared memory mapping with an offset
@ 2024-10-16 18:21 Dmitrii Dolgov <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Dmitrii Dolgov @ 2024-10-16 18:21 UTC (permalink / raw)
Currently the kernel is responsible to chose an address, where to place each
shared memory mapping, which is the lowest possible address that do not clash
with any other mappings. This is considered to be the most portable approach,
but one of the downsides is that there is no place to resize allocated mappings
anymore. Here is how it looks like for one mapping in /proc/$PID/maps,
/dev/zero represents the anonymous shared memory we talk about:
00400000-00490000 /path/bin/postgres
...
012d9000-0133e000 [heap]
7f443a800000-7f470a800000 /dev/zero (deleted)
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
...
7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
By specifying the mapping address directly it's possible to place the
mapping in a way that leaves room for resizing. The idea is first to get
the address chosen by the kernel, then apply some offset derived from
the expected upper limit. Because we base the layout on the address
chosen by the kernel, things like address space randomization should not
be a problem, since the randomization is applied to the mmap base, which
is one per process. The result looks like this:
012d9000-0133e000 [heap]
7f443a800000-7f444196c000 /dev/zero (deleted)
[...free space...]
7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
This approach do not impact the actual memory usage as reported by the kernel.
Here is the output of /proc/$PID/status for the master version with
shared_buffers = 128 MB:
// Peak virtual memory size, which is described as total pages mapped in mm_struct
VmPeak: 422780 kB
// Size of memory portions. It contains RssAnon + RssFile + RssShmem
VmRSS: 21248 kB
// Size of resident anonymous memory
RssAnon: 640 kB
// Size of resident file mappings
RssFile: 9728 kB
// Size of resident shmem memory (includes SysV shm, mapping of tmpfs and
// shared anonymous mappings)
RssShmem: 10880 kB
Here is the same for the patch with the shared mapping placed at
an offset 10 GB:
VmPeak: 1102844 kB
VmRSS: 21376 kB
RssAnon: 640 kB
RssFile: 9856 kB
RssShmem: 10880 kB
Cgroup v2 doesn't have any problems with that as well. To verify a new cgroup
was created with the memory limit 256 MB, then PostgreSQL was launched withing
this cgroup with shared_buffers = 128 MB:
$ cd /sys/fs/cgroup
$ mkdir postgres
$ cd postres
$ echo 268435456 > memory.max
$ echo $MASTER_PID_SHELL > cgroup.procs
# postgres from the master branch has being successfully launched
# from that shell
$ cat memory.current
17465344 (~16 MB)
# stop postgres
$ echo $PATCH_PID_SHELL > cgroup.procs
# postgres from the patch has being successfully launched from that shell
$ cat memory.current
18219008 (~17 MB)
Note that currently the implementation makes assumptions about the upper limit.
Ideally it should be based on the maximum available memory.
---
src/backend/port/sysv_shmem.c | 120 +++++++++++++++++++++++++++++++++-
1 file changed, 119 insertions(+), 1 deletion(-)
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c
index 843b1b3220f..62f01d8218a 100644
--- a/src/backend/port/sysv_shmem.c
+++ b/src/backend/port/sysv_shmem.c
@@ -108,6 +108,63 @@ static AnonymousMapping Mappings[ANON_MAPPINGS];
/* Keeps track of used mapping segments */
static int next_free_segment = 0;
+/*
+ * Anonymous mapping placing (/dev/zero (deleted) below) looks like this:
+ *
+ * 00400000-00490000 /path/bin/postgres
+ * ...
+ * 012d9000-0133e000 [heap]
+ * 7f443a800000-7f470a800000 /dev/zero (deleted)
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ * 7f471aef2000-7f471aef9000 /dev/shm/PostgreSQL.3859891842
+ * 7f471aef9000-7f471aefa000 /SYSV007dbf7d (deleted)
+ * ...
+ *
+ * We would like to place multiple mappings in such a way, that there will be
+ * enough space between them in the address space to be able to resize up to
+ * certain size, but without counting towards the total memory consumption.
+ *
+ * By letting Linux to chose a mapping address, it will pick up the lowest
+ * possible address that do not clash with any other mappings, which will be
+ * right before locales in the example above. This information (maximum allowed
+ * size of mappings and the lowest mapping address) is enough to place every
+ * mapping as follow:
+ *
+ * - Take the lowest mapping address, which we call later the probe address.
+ * - Substract the offset of the previous mapping.
+ * - Substract the maximum allowed size for the current mapping from the
+ * address.
+ * - Place the mapping by the resulting address.
+ *
+ * The result would look like this:
+ *
+ * 012d9000-0133e000 [heap]
+ * 7f4426f54000-7f442e010000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f443a800000-7f444196c000 /dev/zero (deleted)
+ * [...free space...]
+ * 7f470a800000-7f471831d000 /usr/lib/locale/locale-archive
+ * 7f4718400000-7f4718401000 /usr/lib64/libicudata.so.74.2
+ * ...
+ */
+Size SHMEM_EXTRA_SIZE_LIMIT[1] = {
+ 0, /* MAIN_SHMEM_SLOT */
+};
+
+/* Remembers offset of the last mapping from the probe address */
+static Size last_offset = 0;
+
+/*
+ * Size of the mapping, which will be used to calculate anonymous mapping
+ * address. It should not be too small, otherwise there is a chance the probe
+ * mapping will be created between other mappings, leaving no room extending
+ * it. But it should not be too large either, in case if there are limitations
+ * on the mapping size. Current value is the default shared_buffers.
+ */
+#define PROBE_MAPPING_SIZE (Size) 128 * 1024 * 1024
+
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId);
@@ -673,13 +730,74 @@ CreateAnonymousSegment(AnonymousMapping *mapping)
if (ptr == MAP_FAILED && huge_pages != HUGE_PAGES_ON)
{
+ void *probe = NULL;
+
/*
* Use the original size, not the rounded-up value, when falling back
* to non-huge pages.
*/
allocsize = mapping->shmem_size;
- ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+
+ /*
+ * Try to create mapping at an address, which will allow to extend it
+ * later:
+ *
+ * - First create the temporary probe mapping of a fixed size and let
+ * kernel to place it at address of its choice. By the virtue of the
+ * probe mapping size we expect it to be located at the lowest
+ * possible address, expecting some non mapped space above.
+ *
+ * - Unmap the probe mapping, remember the address.
+ *
+ * - Create an actual anonymous mapping at that address with the
+ * offset. The offset is calculated in such a way to allow growing
+ * the mapping withing certain boundaries. For this mapping we use
+ * MAP_FIXED_NOREPLACE, which will error out with EEXIST if there is
+ * any mapping clash.
+ *
+ * - If the last step has failed, fallback to the regular mapping
+ * creation and signal that shared buffers could not be resized
+ * without a restart.
+ */
+ probe = mmap(NULL, PROBE_MAPPING_SIZE, PROT_READ | PROT_WRITE,
PG_MMAP_FLAGS, -1, 0);
+
+ if (probe == MAP_FAILED)
+ {
+ mmap_errno = errno;
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: probe mmap(%zu) failed: %m",
+ MappingName(mapping->shmem_segment), allocsize);
+ }
+ else
+ {
+ Size offset = last_offset + SHMEM_EXTRA_SIZE_LIMIT[next_free_segment] + allocsize;
+ last_offset = offset;
+
+ munmap(probe, PROBE_MAPPING_SIZE);
+
+ ptr = mmap(probe - offset, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS | MAP_FIXED_NOREPLACE, -1, 0);
+ mmap_errno = errno;
+ if (ptr == MAP_FAILED)
+ {
+ DebugMappings();
+ elog(DEBUG1, "segment[%s]: mmap(%zu) at address %p failed: %m",
+ MappingName(mapping->shmem_segment), allocsize, probe - offset);
+ }
+
+ }
+ }
+
+ if (ptr == MAP_FAILED)
+ {
+ /*
+ * Fallback to the portable way of creating a mapping.
+ */
+ allocsize = mapping->shmem_size;
+
+ ptr = mmap(NULL, allocsize, PROT_READ | PROT_WRITE,
+ PG_MMAP_FLAGS, -1, 0);
mmap_errno = errno;
}
--
2.45.1
--q7xzg7duksj2kgko
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment;
filename="v2-0003-Introduce-multiple-shmem-segments-for-shared-buff.patch"
^ permalink raw reply [nested|flat] 163+ messages in thread
* [PATCH 2/5] Refactor index_concurrently_create_copy() for use with REPACK (CONCURRENTLY).
@ 2026-02-16 19:49 Antonin Houska <[email protected]>
0 siblings, 0 replies; 163+ messages in thread
From: Antonin Houska @ 2026-02-16 19:49 UTC (permalink / raw)
This patch moves the code to index_create_copy() and adds a "concurrently"
parameter so it can be used by REPACK (CONCURRENTLY).
With the CONCURRENTLY option, REPACK cannot simply swap the heap file and
rebuild its indexes. Instead, it needs to build a separate set of indexes
(including system catalog entries) *before* the actual swap, to reduce the
time AccessExclusiveLock needs to be held for.
---
src/backend/catalog/index.c | 54 +++++++++++++++++++++++---------
src/backend/commands/indexcmds.c | 6 ++--
src/backend/nodes/makefuncs.c | 9 +++---
src/include/catalog/index.h | 3 ++
src/include/nodes/makefuncs.h | 4 ++-
5 files changed, 54 insertions(+), 22 deletions(-)
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 5ee6389d39c..f8e6c3d804e 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -1288,15 +1288,32 @@ index_create(Relation heapRelation,
/*
* index_concurrently_create_copy
*
- * Create concurrently an index based on the definition of the one provided by
- * caller. The index is inserted into catalogs and needs to be built later
- * on. This is called during concurrent reindex processing.
- *
- * "tablespaceOid" is the tablespace to use for this index.
+ * Variant of index_create_copy(), called during concurrent reindex
+ * processing.
*/
Oid
index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId,
Oid tablespaceOid, const char *newName)
+{
+ return index_create_copy(heapRelation, oldIndexId, tablespaceOid, newName,
+ true);
+}
+
+/*
+ * index_create_copy
+ *
+ * Create an index based on the definition of the one provided by caller. The
+ * index is inserted into catalogs. If 'concurrently' is TRUE, it needs to be
+ * built later on, otherwise it's built immediately.
+ *
+ * "tablespaceOid" is the tablespace to use for this index.
+ *
+ * The actual implementation of index_concurrently_create_copy(), reusable for
+ * other purposes.
+ */
+Oid
+index_create_copy(Relation heapRelation, Oid oldIndexId, Oid tablespaceOid,
+ const char *newName, bool concurrently)
{
Relation indexRelation;
IndexInfo *oldInfo,
@@ -1315,6 +1332,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId,
List *indexColNames = NIL;
List *indexExprs = NIL;
List *indexPreds = NIL;
+ int flags = 0;
indexRelation = index_open(oldIndexId, RowExclusiveLock);
@@ -1325,7 +1343,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId,
* Concurrent build of an index with exclusion constraints is not
* supported.
*/
- if (oldInfo->ii_ExclusionOps != NULL)
+ if (oldInfo->ii_ExclusionOps != NULL && concurrently)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("concurrent index creation for exclusion constraints is not supported")));
@@ -1381,9 +1399,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId,
}
/*
- * Build the index information for the new index. Note that rebuild of
- * indexes with exclusion constraints is not supported, hence there is no
- * need to fill all the ii_Exclusion* fields.
+ * Build the index information for the new index.
*/
newInfo = makeIndexInfo(oldInfo->ii_NumIndexAttrs,
oldInfo->ii_NumIndexKeyAttrs,
@@ -1392,10 +1408,13 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId,
indexPreds,
oldInfo->ii_Unique,
oldInfo->ii_NullsNotDistinct,
- false, /* not ready for inserts */
- true,
+ !concurrently, /* isready */
+ concurrently, /* concurrent */
indexRelation->rd_indam->amsummarizing,
- oldInfo->ii_WithoutOverlaps);
+ oldInfo->ii_WithoutOverlaps,
+ oldInfo->ii_ExclusionOps,
+ oldInfo->ii_ExclusionProcs,
+ oldInfo->ii_ExclusionStrats);
/*
* Extract the list of column names and the column numbers for the new
@@ -1433,6 +1452,9 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId,
stattargets[i].isnull = isnull;
}
+ if (concurrently)
+ flags = INDEX_CREATE_SKIP_BUILD | INDEX_CREATE_CONCURRENT;
+
/*
* Now create the new index.
*
@@ -1456,7 +1478,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId,
indcoloptions->values,
stattargets,
reloptionsDatum,
- INDEX_CREATE_SKIP_BUILD | INDEX_CREATE_CONCURRENT,
+ flags,
0,
true, /* allow table to be a system catalog? */
false, /* is_internal? */
@@ -2450,7 +2472,8 @@ BuildIndexInfo(Relation index)
indexStruct->indisready,
false,
index->rd_indam->amsummarizing,
- indexStruct->indisexclusion && indexStruct->indisunique);
+ indexStruct->indisexclusion && indexStruct->indisunique,
+ NULL, NULL, NULL);
/* fill in attribute numbers */
for (i = 0; i < numAtts; i++)
@@ -2510,7 +2533,8 @@ BuildDummyIndexInfo(Relation index)
indexStruct->indisready,
false,
index->rd_indam->amsummarizing,
- indexStruct->indisexclusion && indexStruct->indisunique);
+ indexStruct->indisexclusion && indexStruct->indisunique,
+ NULL, NULL, NULL);
/* fill in attribute numbers */
for (i = 0; i < numAtts; i++)
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index 635679cc1f2..34209bd1393 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -243,7 +243,8 @@ CheckIndexCompatible(Oid oldId,
*/
indexInfo = makeIndexInfo(numberOfAttributes, numberOfAttributes,
accessMethodId, NIL, NIL, false, false,
- false, false, amsummarizing, isWithoutOverlaps);
+ false, false, amsummarizing, isWithoutOverlaps,
+ NULL, NULL, NULL);
typeIds = palloc_array(Oid, numberOfAttributes);
collationIds = palloc_array(Oid, numberOfAttributes);
opclassIds = palloc_array(Oid, numberOfAttributes);
@@ -930,7 +931,8 @@ DefineIndex(ParseState *pstate,
!concurrent,
concurrent,
amissummarizing,
- stmt->iswithoutoverlaps);
+ stmt->iswithoutoverlaps,
+ NULL, NULL, NULL);
typeIds = palloc_array(Oid, numberOfAttributes);
collationIds = palloc_array(Oid, numberOfAttributes);
diff --git a/src/backend/nodes/makefuncs.c b/src/backend/nodes/makefuncs.c
index 2caec621d73..ca7e21e8349 100644
--- a/src/backend/nodes/makefuncs.c
+++ b/src/backend/nodes/makefuncs.c
@@ -834,7 +834,8 @@ IndexInfo *
makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions,
List *predicates, bool unique, bool nulls_not_distinct,
bool isready, bool concurrent, bool summarizing,
- bool withoutoverlaps)
+ bool withoutoverlaps, Oid *exclusion_ops, Oid *exclusion_procs,
+ uint16 *exclusion_strats)
{
IndexInfo *n = makeNode(IndexInfo);
@@ -863,9 +864,9 @@ makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions,
n->ii_PredicateState = NULL;
/* exclusion constraints */
- n->ii_ExclusionOps = NULL;
- n->ii_ExclusionProcs = NULL;
- n->ii_ExclusionStrats = NULL;
+ n->ii_ExclusionOps = exclusion_ops;
+ n->ii_ExclusionProcs = exclusion_procs;
+ n->ii_ExclusionStrats = exclusion_strats;
/* speculative inserts */
n->ii_UniqueOps = NULL;
diff --git a/src/include/catalog/index.h b/src/include/catalog/index.h
index b259c4141ed..3426087b445 100644
--- a/src/include/catalog/index.h
+++ b/src/include/catalog/index.h
@@ -99,6 +99,9 @@ extern Oid index_concurrently_create_copy(Relation heapRelation,
Oid oldIndexId,
Oid tablespaceOid,
const char *newName);
+extern Oid index_create_copy(Relation heapRelation, Oid oldIndexId,
+ Oid tablespaceOid, const char *newName,
+ bool concurrently);
extern void index_concurrently_build(Oid heapRelationId,
Oid indexRelationId);
diff --git a/src/include/nodes/makefuncs.h b/src/include/nodes/makefuncs.h
index 982ec25ae14..dcea148ae1a 100644
--- a/src/include/nodes/makefuncs.h
+++ b/src/include/nodes/makefuncs.h
@@ -99,7 +99,9 @@ extern IndexInfo *makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid,
List *expressions, List *predicates,
bool unique, bool nulls_not_distinct,
bool isready, bool concurrent,
- bool summarizing, bool withoutoverlaps);
+ bool summarizing, bool withoutoverlaps,
+ Oid *exclusion_ops, Oid *exclusion_procs,
+ uint16 *exclusion_strats);
extern Node *makeStringConst(char *str, int location);
extern DefElem *makeDefElem(char *name, Node *arg, int location);
--
2.47.3
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v34-0003-Move-conversion-of-a-historic-to-MVCC-snapshot-to-a-.patch
^ permalink raw reply [nested|flat] 163+ messages in thread
end of thread, other threads:[~2026-02-16 19:49 UTC | newest]
Thread overview: 163+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v1 2/5] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2024-10-16 18:21 [PATCH v2 2/6] Allow placing shared memory mapping with an offset Dmitrii Dolgov <[email protected]>
2026-02-16 19:49 [PATCH 2/5] Refactor index_concurrently_create_copy() for use with REPACK (CONCURRENTLY). Antonin Houska <[email protected]>
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox