From d962b1a9b5e2852706e256abbb6d9ca5155842a7 Mon Sep 17 00:00:00 2001 From: Daniil Davidov Date: Thu, 6 Feb 2025 14:34:36 +0700 Subject: [PATCH] SLRU_PAGES_PER_SEGMENT as configure parameter --- configure | 52 ++++++++ src/backend/utils/misc/guc_tables.c | 12 ++ src/include/access/slru.h | 15 --- src/include/pg_config.h.in | 13 ++ .../modules/test_slru/expected/test_slru.out | 123 ++++++++++-------- src/test/modules/test_slru/sql/test_slru.sql | 122 +++++++++++------ src/test/modules/test_slru/test_slru.c | 6 - 7 files changed, 228 insertions(+), 115 deletions(-) diff --git a/configure b/configure index 97996b7f6b..514418e589 100755 --- a/configure +++ b/configure @@ -845,6 +845,7 @@ enable_dtrace enable_tap_tests enable_injection_points with_blocksize +with_slru_pps with_segsize with_segsize_blocks with_wal_blocksize @@ -1559,6 +1560,7 @@ Optional Packages: set table segment size in blocks [0] --with-wal-blocksize=BLOCKSIZE set WAL block size in kB [8] + --with-slru-pps=SLRUPPS set slru segment size in blocks --with-llvm build with LLVM based JIT support --without-icu build without ICU support --with-tcl build Tcl modules (PL/Tcl) @@ -3762,6 +3764,56 @@ cat >>confdefs.h <<_ACEOF _ACEOF +# +# SLRU pages per segment +# +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for slru pages per segment" >&5 +$as_echo_n "checking for slru pages per segment... " >&6; } + + + +# Check whether --with-slru-pps was given. +if test "${with_slru_pps+set}" = set; then : + withval=$with_slru_pps; + case $withval in + yes) + as_fn_error $? "argument required for --with_slru_pps option" "$LINENO" 5 + ;; + no) + as_fn_error $? "argument required for --with_slru_pps option" "$LINENO" 5 + ;; + *) + slru_pages_per_segment=$withval + ;; + esac + +else + slru_pages_per_segment=32 +fi + + +INT_MAX=2147483647 +if test "${slru_pages_per_segment}" -lt 32; then + as_fn_error $? "Invalid slru_pps value. It cannot be less, then 32." "$LINENO" 5 + exit 1 +elif test "${slru_pages_per_segment}" -gt "${INT_MAX}"; then + as_fn_error $? "Invalid slru_pps value. It cannot be greater, then INT_MAX." "$LINENO" 5 + exit 1 +elif test $((${slru_pages_per_segment} % 2)) -ne 0; then + as_fn_error $? "Invalid slru_pps value. It must be a power of 2." "$LINENO" 5 + exit 1 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${slru_pages_per_segment}" >&5 +$as_echo "${slru_pages_per_segment}" >&6; } + + +cat >>confdefs.h <<_ACEOF +#define SLRU_PAGES_PER_SEGMENT ${slru_pages_per_segment} +_ACEOF + + + + # # Relation segment size # diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c index c42fccf3fe..bf1aa3a56c 100644 --- a/src/backend/utils/misc/guc_tables.c +++ b/src/backend/utils/misc/guc_tables.c @@ -596,6 +596,7 @@ static int max_function_args; static int max_index_keys; static int max_identifier_length; static int block_size; +static int slru_pages_per_segment; static int segment_size; static int shared_memory_size_mb; static int shared_memory_size_in_huge_pages; @@ -3266,6 +3267,17 @@ struct config_int ConfigureNamesInt[] = NULL, NULL, NULL }, + { + {"slru_pps", PGC_INTERNAL, PRESET_OPTIONS, + gettext_noop("Shows the number of slru pages per segment."), + NULL, + GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE + }, + &slru_pages_per_segment, + SLRU_PAGES_PER_SEGMENT, SLRU_PAGES_PER_SEGMENT, SLRU_PAGES_PER_SEGMENT, + NULL, NULL, NULL + }, + { {"segment_size", PGC_INTERNAL, PRESET_OPTIONS, gettext_noop("Shows the number of pages per disk file."), diff --git a/src/include/access/slru.h b/src/include/access/slru.h index 02fcb3bca5..c75fc215d1 100644 --- a/src/include/access/slru.h +++ b/src/include/access/slru.h @@ -23,21 +23,6 @@ */ #define SLRU_MAX_ALLOWED_BUFFERS ((1024 * 1024 * 1024) / BLCKSZ) -/* - * Define SLRU segment size. A page is the same BLCKSZ as is used everywhere - * else in Postgres. The segment size can be chosen somewhat arbitrarily; - * we make it 32 pages by default, or 256Kb, i.e. 1M transactions for CLOG - * or 64K transactions for SUBTRANS. - * - * Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF, - * page numbering also wraps around at 0xFFFFFFFF/xxxx_XACTS_PER_PAGE (where - * xxxx is CLOG or SUBTRANS, respectively), and segment numbering at - * 0xFFFFFFFF/xxxx_XACTS_PER_PAGE/SLRU_PAGES_PER_SEGMENT. We need - * take no explicit notice of that fact in slru.c, except when comparing - * segment and page numbers in SimpleLruTruncate (see PagePrecedes()). - */ -#define SLRU_PAGES_PER_SEGMENT 32 - /* * Page status codes. Note that these do not include the "dirty" bit. * page_dirty can be true only in the VALID or WRITE_IN_PROGRESS states; diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in index 2397d90b46..54f5d366fd 100644 --- a/src/include/pg_config.h.in +++ b/src/include/pg_config.h.in @@ -30,6 +30,19 @@ Changing BLCKSZ requires an initdb. */ #undef BLCKSZ +/* SLRU segment size. A page is the same BLCKSZ as is used everywhere + * else in Postgres. The segment size can be chosen somewhat arbitrarily; + * we make it 32 pages by default, or 256Kb, i.e. 1M transactions for CLOG + * or 64K transactions for SUBTRANS. + * + * Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF, + * page numbering also wraps around at 0xFFFFFFFF/xxxx_XACTS_PER_PAGE (where + * xxxx is CLOG or SUBTRANS, respectively), and segment numbering at + * 0xFFFFFFFF/xxxx_XACTS_PER_PAGE/SLRU_PAGES_PER_SEGMENT. We need + * take no explicit notice of that fact in slru.c, except when comparing + * segment and page numbers in SimpleLruTruncate (see PagePrecedes()). */ +#undef SLRU_PAGES_PER_SEGMENT + /* Saved arguments from configure */ #undef CONFIGURE_ARGS diff --git a/src/test/modules/test_slru/expected/test_slru.out b/src/test/modules/test_slru/expected/test_slru.out index 185c56e5d6..1184db276d 100644 --- a/src/test/modules/test_slru/expected/test_slru.out +++ b/src/test/modules/test_slru/expected/test_slru.out @@ -1,52 +1,62 @@ CREATE EXTENSION test_slru; -SELECT test_slru_page_exists(12345); +-- how many pages can fit on one slru segment +SELECT current_setting('slru_pps')::INT AS slru_pps \gset +SELECT (:slru_pps * 6.8125) AS pageno \gset +-- count from zero +SELECT (:pageno + (:slru_pps * 1.5) - 1) AS pageno_max \gset +SELECT (:pageno_max - (:slru_pps / 2)) AS pageno_middle \gset +-- non existed page +SELECT test_slru_page_exists(:pageno::BIGINT); test_slru_page_exists ----------------------- f (1 row) -SELECT test_slru_page_write(12345, 'Test SLRU'); +SELECT test_slru_page_write(:pageno::BIGINT, 'Test SLRU'); test_slru_page_write ---------------------- (1 row) -SELECT test_slru_page_read(12345); +SELECT test_slru_page_read(:pageno::BIGINT); test_slru_page_read --------------------- Test SLRU (1 row) -SELECT test_slru_page_exists(12345); +SELECT test_slru_page_exists(:pageno::BIGINT); test_slru_page_exists ----------------------- t (1 row) --- 48 extra pages -SELECT count(test_slru_page_write(a, 'Test SLRU')) - FROM generate_series(12346, 12393, 1) as a; - count -------- - 48 -(1 row) - +-- Generate extra pages. Redirect output into table because number of funciton +-- calls depends on the current value of slru_pps parameter. +CREATE TABLE slru_write_results ( + pageno BIGINT, + write_count INTEGER +); +INSERT INTO slru_write_results (pageno, write_count) +SELECT a, count(test_slru_page_write(a::BIGINT, 'Test SLRU')) +FROM generate_series(:pageno, :pageno_max, 1) AS a +GROUP BY a; +DROP TABLE slru_write_results; -- Reading page in buffer for read and write -SELECT test_slru_page_read(12377, true); +SELECT test_slru_page_read(:pageno_middle::BIGINT, true); test_slru_page_read --------------------- Test SLRU (1 row) -- Reading page in buffer for read-only -SELECT test_slru_page_readonly(12377); +SELECT test_slru_page_readonly(:pageno_middle::BIGINT); test_slru_page_readonly ------------------------- Test SLRU (1 row) -- Reading page not in buffer with read-only -SELECT test_slru_page_readonly(12346); +SELECT test_slru_page_readonly(:pageno::BIGINT); test_slru_page_readonly ------------------------- Test SLRU @@ -60,47 +70,45 @@ SELECT test_slru_page_writeall(); (1 row) -- Flush the last page written out. -SELECT test_slru_page_sync(12393); -NOTICE: Called SlruSyncFileTag() for segment 387 on path pg_test_slru/000000000000183 +SELECT test_slru_page_sync(:pageno_max::BIGINT); test_slru_page_sync --------------------- (1 row) -SELECT test_slru_page_exists(12393); +SELECT test_slru_page_exists(:pageno_max::BIGINT); test_slru_page_exists ----------------------- t (1 row) -- Segment deletion -SELECT test_slru_page_delete(12393); -NOTICE: Called SlruDeleteSegment() for segment 387 +SELECT test_slru_page_delete(:pageno_max::BIGINT); test_slru_page_delete ----------------------- (1 row) -SELECT test_slru_page_exists(12393); +SELECT test_slru_page_exists(:pageno_max::BIGINT); test_slru_page_exists ----------------------- f (1 row) -- Page truncation -SELECT test_slru_page_exists(12377); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); test_slru_page_exists ----------------------- t (1 row) -SELECT test_slru_page_truncate(12377); +SELECT test_slru_page_truncate(:pageno_middle::BIGINT); test_slru_page_truncate ------------------------- (1 row) -SELECT test_slru_page_exists(12377); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); test_slru_page_exists ----------------------- t @@ -114,19 +122,19 @@ NOTICE: Calling test_slru_scan_cb() (1 row) -SELECT test_slru_page_exists(12345); +SELECT test_slru_page_exists(:pageno::BIGINT); test_slru_page_exists ----------------------- f (1 row) -SELECT test_slru_page_exists(12377); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); test_slru_page_exists ----------------------- f (1 row) -SELECT test_slru_page_exists(12393); +SELECT test_slru_page_exists(:pageno_max::BIGINT); test_slru_page_exists ----------------------- f @@ -135,54 +143,63 @@ SELECT test_slru_page_exists(12393); -- -- Test 64-bit pages -- -SELECT test_slru_page_exists(0x1234500000000); +\set no_such_page 0x1234500000000 +-- second page in SLRU segments +\set pageno 0x1234500000001 +-- count from zero +SELECT (:no_such_page + (:slru_pps * 1.5)) AS pageno_max \gset +SELECT (:pageno_max - (:slru_pps / 2)) AS pageno_middle \gset +SELECT test_slru_page_exists(:no_such_page); test_slru_page_exists ----------------------- f (1 row) -SELECT test_slru_page_write(0x1234500000000, 'Test SLRU 64-bit'); +SELECT test_slru_page_write(:no_such_page, 'Test SLRU 64-bit'); test_slru_page_write ---------------------- (1 row) -SELECT test_slru_page_read(0x1234500000000); +SELECT test_slru_page_read(:no_such_page); test_slru_page_read --------------------- Test SLRU 64-bit (1 row) -SELECT test_slru_page_exists(0x1234500000000); +SELECT test_slru_page_exists(:no_such_page); test_slru_page_exists ----------------------- t (1 row) --- 48 extra pages -SELECT count(test_slru_page_write(a, 'Test SLRU 64-bit')) - FROM generate_series(0x1234500000001, 0x1234500000030, 1) as a; - count -------- - 48 -(1 row) - +-- Generate extra pages. Redirect output into table because number of funciton +-- calls depends on the current value of slru_pps parameter. +CREATE TABLE slru_write_results ( + pageno BIGINT, + write_count INTEGER +); +INSERT INTO slru_write_results (pageno, write_count) +SELECT a, count(test_slru_page_write(a::BIGINT, 'Test SLRU 64-bit')) +FROM generate_series(:pageno, :pageno_max, 1) AS a +GROUP BY a; +DROP TABLE slru_write_results; -- Reading page in buffer for read and write -SELECT test_slru_page_read(0x1234500000020, true); +SELECT test_slru_page_read(:pageno_middle::BIGINT, true); test_slru_page_read --------------------- Test SLRU 64-bit (1 row) -- Reading page in buffer for read-only -SELECT test_slru_page_readonly(0x1234500000020); +SELECT test_slru_page_readonly(:pageno_middle::BIGINT); test_slru_page_readonly ------------------------- Test SLRU 64-bit (1 row) -- Reading page not in buffer with read-only -SELECT test_slru_page_readonly(0x1234500000001); +SELECT test_slru_page_readonly(:pageno); test_slru_page_readonly ------------------------- Test SLRU 64-bit @@ -196,47 +213,45 @@ SELECT test_slru_page_writeall(); (1 row) -- Flush the last page written out. -SELECT test_slru_page_sync(0x1234500000030); -NOTICE: Called SlruSyncFileTag() for segment 10007944888321 on path pg_test_slru/000091A28000001 +SELECT test_slru_page_sync(:pageno_max::BIGINT); test_slru_page_sync --------------------- (1 row) -SELECT test_slru_page_exists(0x1234500000030); +SELECT test_slru_page_exists(:pageno_max::BIGINT); test_slru_page_exists ----------------------- t (1 row) -- Segment deletion -SELECT test_slru_page_delete(0x1234500000030); -NOTICE: Called SlruDeleteSegment() for segment 10007944888321 +SELECT test_slru_page_delete(:pageno_max::BIGINT); test_slru_page_delete ----------------------- (1 row) -SELECT test_slru_page_exists(0x1234500000030); +SELECT test_slru_page_exists(:pageno_max::BIGINT); test_slru_page_exists ----------------------- f (1 row) -- Page truncation -SELECT test_slru_page_exists(0x1234500000020); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); test_slru_page_exists ----------------------- f (1 row) -SELECT test_slru_page_truncate(0x1234500000020); +SELECT test_slru_page_truncate(:pageno_middle::BIGINT); test_slru_page_truncate ------------------------- (1 row) -SELECT test_slru_page_exists(0x1234500000020); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); test_slru_page_exists ----------------------- f @@ -249,19 +264,19 @@ SELECT test_slru_delete_all(); (1 row) -SELECT test_slru_page_exists(0x1234500000000); +SELECT test_slru_page_exists(:no_such_page); test_slru_page_exists ----------------------- f (1 row) -SELECT test_slru_page_exists(0x1234500000020); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); test_slru_page_exists ----------------------- f (1 row) -SELECT test_slru_page_exists(0x1234500000030); +SELECT test_slru_page_exists(:pageno_max::BIGINT); test_slru_page_exists ----------------------- f diff --git a/src/test/modules/test_slru/sql/test_slru.sql b/src/test/modules/test_slru/sql/test_slru.sql index b1b376581a..ee6bd32353 100644 --- a/src/test/modules/test_slru/sql/test_slru.sql +++ b/src/test/modules/test_slru/sql/test_slru.sql @@ -1,76 +1,118 @@ CREATE EXTENSION test_slru; -SELECT test_slru_page_exists(12345); -SELECT test_slru_page_write(12345, 'Test SLRU'); -SELECT test_slru_page_read(12345); -SELECT test_slru_page_exists(12345); +-- how many pages can fit on one slru segment +SELECT current_setting('slru_pps')::INT AS slru_pps \gset --- 48 extra pages -SELECT count(test_slru_page_write(a, 'Test SLRU')) - FROM generate_series(12346, 12393, 1) as a; +SELECT (:slru_pps * 6.8125) AS pageno \gset + +-- count from zero +SELECT (:pageno + (:slru_pps * 1.5) - 1) AS pageno_max \gset + +SELECT (:pageno_max - (:slru_pps / 2)) AS pageno_middle \gset + +-- non existed page +SELECT test_slru_page_exists(:pageno::BIGINT); +SELECT test_slru_page_write(:pageno::BIGINT, 'Test SLRU'); +SELECT test_slru_page_read(:pageno::BIGINT); +SELECT test_slru_page_exists(:pageno::BIGINT); + +-- Generate extra pages. Redirect output into table because number of funciton +-- calls depends on the current value of slru_pps parameter. + +CREATE TABLE slru_write_results ( + pageno BIGINT, + write_count INTEGER +); + +INSERT INTO slru_write_results (pageno, write_count) +SELECT a, count(test_slru_page_write(a::BIGINT, 'Test SLRU')) +FROM generate_series(:pageno, :pageno_max, 1) AS a +GROUP BY a; + +DROP TABLE slru_write_results; -- Reading page in buffer for read and write -SELECT test_slru_page_read(12377, true); +SELECT test_slru_page_read(:pageno_middle::BIGINT, true); -- Reading page in buffer for read-only -SELECT test_slru_page_readonly(12377); +SELECT test_slru_page_readonly(:pageno_middle::BIGINT); -- Reading page not in buffer with read-only -SELECT test_slru_page_readonly(12346); +SELECT test_slru_page_readonly(:pageno::BIGINT); -- Write all the pages in buffers SELECT test_slru_page_writeall(); -- Flush the last page written out. -SELECT test_slru_page_sync(12393); -SELECT test_slru_page_exists(12393); +SELECT test_slru_page_sync(:pageno_max::BIGINT); +SELECT test_slru_page_exists(:pageno_max::BIGINT); -- Segment deletion -SELECT test_slru_page_delete(12393); -SELECT test_slru_page_exists(12393); +SELECT test_slru_page_delete(:pageno_max::BIGINT); +SELECT test_slru_page_exists(:pageno_max::BIGINT); -- Page truncation -SELECT test_slru_page_exists(12377); -SELECT test_slru_page_truncate(12377); -SELECT test_slru_page_exists(12377); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); +SELECT test_slru_page_truncate(:pageno_middle::BIGINT); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); -- Full deletion SELECT test_slru_delete_all(); -SELECT test_slru_page_exists(12345); -SELECT test_slru_page_exists(12377); -SELECT test_slru_page_exists(12393); +SELECT test_slru_page_exists(:pageno::BIGINT); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); +SELECT test_slru_page_exists(:pageno_max::BIGINT); -- -- Test 64-bit pages -- -SELECT test_slru_page_exists(0x1234500000000); -SELECT test_slru_page_write(0x1234500000000, 'Test SLRU 64-bit'); -SELECT test_slru_page_read(0x1234500000000); -SELECT test_slru_page_exists(0x1234500000000); +\set no_such_page 0x1234500000000 +-- second page in SLRU segments +\set pageno 0x1234500000001 + +-- count from zero +SELECT (:no_such_page + (:slru_pps * 1.5)) AS pageno_max \gset + +SELECT (:pageno_max - (:slru_pps / 2)) AS pageno_middle \gset + +SELECT test_slru_page_exists(:no_such_page); +SELECT test_slru_page_write(:no_such_page, 'Test SLRU 64-bit'); +SELECT test_slru_page_read(:no_such_page); +SELECT test_slru_page_exists(:no_such_page); + +-- Generate extra pages. Redirect output into table because number of funciton +-- calls depends on the current value of slru_pps parameter. + +CREATE TABLE slru_write_results ( + pageno BIGINT, + write_count INTEGER +); + +INSERT INTO slru_write_results (pageno, write_count) +SELECT a, count(test_slru_page_write(a::BIGINT, 'Test SLRU 64-bit')) +FROM generate_series(:pageno, :pageno_max, 1) AS a +GROUP BY a; --- 48 extra pages -SELECT count(test_slru_page_write(a, 'Test SLRU 64-bit')) - FROM generate_series(0x1234500000001, 0x1234500000030, 1) as a; +DROP TABLE slru_write_results; -- Reading page in buffer for read and write -SELECT test_slru_page_read(0x1234500000020, true); +SELECT test_slru_page_read(:pageno_middle::BIGINT, true); -- Reading page in buffer for read-only -SELECT test_slru_page_readonly(0x1234500000020); +SELECT test_slru_page_readonly(:pageno_middle::BIGINT); -- Reading page not in buffer with read-only -SELECT test_slru_page_readonly(0x1234500000001); +SELECT test_slru_page_readonly(:pageno); -- Write all the pages in buffers SELECT test_slru_page_writeall(); -- Flush the last page written out. -SELECT test_slru_page_sync(0x1234500000030); -SELECT test_slru_page_exists(0x1234500000030); +SELECT test_slru_page_sync(:pageno_max::BIGINT); +SELECT test_slru_page_exists(:pageno_max::BIGINT); -- Segment deletion -SELECT test_slru_page_delete(0x1234500000030); -SELECT test_slru_page_exists(0x1234500000030); +SELECT test_slru_page_delete(:pageno_max::BIGINT); +SELECT test_slru_page_exists(:pageno_max::BIGINT); -- Page truncation -SELECT test_slru_page_exists(0x1234500000020); -SELECT test_slru_page_truncate(0x1234500000020); -SELECT test_slru_page_exists(0x1234500000020); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); +SELECT test_slru_page_truncate(:pageno_middle::BIGINT); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); -- Full deletion SELECT test_slru_delete_all(); -SELECT test_slru_page_exists(0x1234500000000); -SELECT test_slru_page_exists(0x1234500000020); -SELECT test_slru_page_exists(0x1234500000030); +SELECT test_slru_page_exists(:no_such_page); +SELECT test_slru_page_exists(:pageno_middle::BIGINT); +SELECT test_slru_page_exists(:pageno_max::BIGINT); DROP EXTENSION test_slru; diff --git a/src/test/modules/test_slru/test_slru.c b/src/test/modules/test_slru/test_slru.c index d227b06703..7c55798dc8 100644 --- a/src/test/modules/test_slru/test_slru.c +++ b/src/test/modules/test_slru/test_slru.c @@ -151,9 +151,6 @@ test_slru_page_sync(PG_FUNCTION_ARGS) ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT; SlruSyncFileTag(TestSlruCtl, &ftag, path); - elog(NOTICE, "Called SlruSyncFileTag() for segment %lld on path %s", - (long long) ftag.segno, path); - PG_RETURN_VOID(); } @@ -166,9 +163,6 @@ test_slru_page_delete(PG_FUNCTION_ARGS) ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT; SlruDeleteSegment(TestSlruCtl, ftag.segno); - elog(NOTICE, "Called SlruDeleteSegment() for segment %lld", - (long long) ftag.segno); - PG_RETURN_VOID(); } -- 2.43.0