agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH v3 3/3] Change force_parallel_mode to a DEVELOPER GUC, and remove it from sample config.. 8+ messages / 2 participants [nested] [flat]
* [PATCH v3 3/3] Change force_parallel_mode to a DEVELOPER GUC, and remove it from sample config.. @ 2021-04-04 00:24 Justin Pryzby <pryzbyj@telsasoft.com> 0 siblings, 0 replies; 8+ messages in thread From: Justin Pryzby @ 2021-04-04 00:24 UTC (permalink / raw) ..to discourage users from changing this option in hopes that it'll make their queries faster, but without reading the documentation or understanding what it does. --- doc/src/sgml/config.sgml | 96 ++++++++++--------- src/backend/utils/misc/guc.c | 2 +- src/backend/utils/misc/postgresql.conf.sample | 1 - 3 files changed, 50 insertions(+), 49 deletions(-) diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml index f749fe9ce7..a7350c6ddc 100644 --- a/doc/src/sgml/config.sgml +++ b/doc/src/sgml/config.sgml @@ -5912,51 +5912,6 @@ SELECT * FROM parent WHERE key = 2400; </listitem> </varlistentry> - <varlistentry id="guc-force-parallel-mode" xreflabel="force_parallel_mode"> - <term><varname>force_parallel_mode</varname> (<type>enum</type>) - <indexterm> - <primary><varname>force_parallel_mode</varname> configuration parameter</primary> - </indexterm> - </term> - <listitem> - <para> - Allows the use of parallel queries for testing purposes even in cases - where no performance benefit is expected. - The allowed values of <varname>force_parallel_mode</varname> are - <literal>off</literal> (use parallel mode only when it is expected to improve - performance), <literal>on</literal> (force parallel query for all queries - for which it is thought to be safe), and <literal>regress</literal> (like - <literal>on</literal>, but with additional behavior changes as explained - below). - </para> - - <para> - More specifically, setting this value to <literal>on</literal> will add - a <literal>Gather</literal> node to the top of any query plan for which this - appears to be safe, so that the query runs inside of a parallel worker. - Even when a parallel worker is not available or cannot be used, - operations such as starting a subtransaction that would be prohibited - in a parallel query context will be prohibited unless the planner - believes that this will cause the query to fail. If failures or - unexpected results occur when this option is set, some functions used - by the query may need to be marked <literal>PARALLEL UNSAFE</literal> - (or, possibly, <literal>PARALLEL RESTRICTED</literal>). - </para> - - <para> - Setting this value to <literal>regress</literal> has all of the same effects - as setting it to <literal>on</literal> plus some additional effects that are - intended to facilitate automated regression testing. Normally, - messages from a parallel worker include a context line indicating that, - but a setting of <literal>regress</literal> suppresses this line so that the - output is the same as in non-parallel execution. Also, - the <literal>Gather</literal> nodes added to plans by this setting are hidden - in <literal>EXPLAIN</literal> output so that the output matches what - would be obtained if this setting were turned <literal>off</literal>. - </para> - </listitem> - </varlistentry> - <varlistentry id="guc-plan-cache_mode" xreflabel="plan_cache_mode"> <term><varname>plan_cache_mode</varname> (<type>enum</type>) <indexterm> @@ -10374,8 +10329,10 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir' <title>Developer Options</title> <para> - The following parameters are intended for work on the - <productname>PostgreSQL</productname> source code, and in some cases + The following parameters are intended for development with + <productname>PostgreSQL</productname>. Some of them are useful while + writing SQL queries, some of them are useful when + working on the source code of PostgreSQL itself, and to assist with recovery of severely damaged databases. There should be no reason to use them on a production database. As such, they have been excluded from the sample @@ -10464,6 +10421,51 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir' </listitem> </varlistentry> + <varlistentry id="guc-force-parallel-mode" xreflabel="force_parallel_mode"> + <term><varname>force_parallel_mode</varname> (<type>enum</type>) + <indexterm> + <primary><varname>force_parallel_mode</varname> configuration parameter</primary> + </indexterm> + </term> + <listitem> + <para> + Allows the use of parallel queries for testing purposes even in cases + where no performance benefit is expected. + The allowed values of <varname>force_parallel_mode</varname> are + <literal>off</literal> (use parallel mode only when it is expected to improve + performance), <literal>on</literal> (force parallel query for all queries + for which it is thought to be safe), and <literal>regress</literal> (like + <literal>on</literal>, but with additional behavior changes as explained + below). + </para> + + <para> + More specifically, setting this value to <literal>on</literal> will add + a <literal>Gather</literal> node to the top of any query plan for which this + appears to be safe, so that the query runs inside of a parallel worker. + Even when a parallel worker is not available or cannot be used, + operations such as starting a subtransaction that would be prohibited + in a parallel query context will be prohibited unless the planner + believes that this will cause the query to fail. If failures or + unexpected results occur when this option is set, some functions used + by the query may need to be marked <literal>PARALLEL UNSAFE</literal> + (or, possibly, <literal>PARALLEL RESTRICTED</literal>). + </para> + + <para> + Setting this value to <literal>regress</literal> has all of the same effects + as setting it to <literal>on</literal> plus some additional effects that are + intended to facilitate automated regression testing. Normally, + messages from a parallel worker include a context line indicating that, + but a setting of <literal>regress</literal> suppresses this line so that the + output is the same as in non-parallel execution. Also, + the <literal>Gather</literal> nodes added to plans by this setting are hidden + in <literal>EXPLAIN</literal> output so that the output matches what + would be obtained if this setting were turned <literal>off</literal>. + </para> + </listitem> + </varlistentry> + <varlistentry id="guc-ignore-system-indexes" xreflabel="ignore_system_indexes"> <term><varname>ignore_system_indexes</varname> (<type>boolean</type>) <indexterm> diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c index a3c2ebbc53..b8738561e6 100644 --- a/src/backend/utils/misc/guc.c +++ b/src/backend/utils/misc/guc.c @@ -4922,7 +4922,7 @@ static struct config_enum ConfigureNamesEnum[] = }, { - {"force_parallel_mode", PGC_USERSET, QUERY_TUNING_OTHER, + {"force_parallel_mode", PGC_USERSET, DEVELOPER_OPTIONS, gettext_noop("Forces use of parallel query facilities."), gettext_noop("If possible, run query using a parallel worker and with parallel restrictions."), GUC_EXPLAIN diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample index 2f6dd014a8..0f7f49b949 100644 --- a/src/backend/utils/misc/postgresql.conf.sample +++ b/src/backend/utils/misc/postgresql.conf.sample @@ -421,7 +421,6 @@ #from_collapse_limit = 8 #join_collapse_limit = 8 # 1 disables collapsing of explicit # JOIN clauses -#force_parallel_mode = off #jit = on # allow JIT compilation #plan_cache_mode = auto # auto, force_generic_plan or # force_custom_plan -- 2.17.0 --oC1+HKm2/end4ao3-- ^ permalink raw reply [nested|flat] 8+ messages in thread
* [PATCH v2.8 26/38] aio: Basic read_stream adjustments for real AIO @ 2025-03-14 15:39 Andres Freund <andres@anarazel.de> 0 siblings, 0 replies; 8+ messages in thread From: Andres Freund @ 2025-03-14 15:39 UTC (permalink / raw) Adapt the read stream logic for real AIO: - If AIO is enabled, we shouldn't issue advice, but if it isn't, we should continue issuing advice - AIO benefits from reading ahead with direct IO - While in read_stream_look_ahead(), we can use AIO batch submission mode for increased efficiency There is one comment talking about max_ios logic with "real asynchronous I/O" that I am not sure about, so I left it alone for now. There are further improvements we should consider, e.g. waiting to issue IOs until we can issue multiple IOs at once. But that's left for a future change, since it would involve additional heuristics. --- src/backend/storage/aio/read_stream.c | 39 ++++++++++++++++++++------- 1 file changed, 29 insertions(+), 10 deletions(-) diff --git a/src/backend/storage/aio/read_stream.c b/src/backend/storage/aio/read_stream.c index 0f1525f46c5..b44cc358f29 100644 --- a/src/backend/storage/aio/read_stream.c +++ b/src/backend/storage/aio/read_stream.c @@ -72,6 +72,7 @@ #include "postgres.h" #include "miscadmin.h" +#include "storage/aio.h" #include "storage/fd.h" #include "storage/smgr.h" #include "storage/read_stream.h" @@ -99,6 +100,7 @@ struct ReadStream int16 pinned_buffers; int16 distance; int16 initialized_buffers; + bool sync_mode; bool advice_enabled; bool temporary; @@ -420,6 +422,13 @@ read_stream_start_pending_read(ReadStream *stream) static void read_stream_look_ahead(ReadStream *stream) { + /* + * Allow amortizing the cost of submitting IO over multiple IOs. This + * requires that we don't do any operations that could lead to a deadlock + * with staged-but-unsubmitted IO. + */ + pgaio_enter_batchmode(); + while (stream->ios_in_progress < stream->max_ios && stream->pinned_buffers + stream->pending_read_nblocks < stream->distance) { @@ -467,6 +476,7 @@ read_stream_look_ahead(ReadStream *stream) { /* We've hit the buffer or I/O limit. Rewind and stop here. */ read_stream_unget_block(stream, blocknum); + pgaio_exit_batchmode(); return; } } @@ -501,6 +511,8 @@ read_stream_look_ahead(ReadStream *stream) * time. */ Assert(stream->pinned_buffers > 0 || stream->distance == 0); + + pgaio_exit_batchmode(); } /* @@ -556,12 +568,12 @@ read_stream_begin_impl(int flags, max_ios = get_tablespace_io_concurrency(tablespace_id); /* - * XXX Since we don't have asynchronous I/O yet, if direct I/O is enabled - * then just behave as though I/O concurrency is set to 0. Otherwise we - * would look ahead pinning many buffers for no benefit, for lack of - * advice and AIO. + * If real asynchronous I/O is disabled, and direct I/O is enabled, just + * behave as though I/O concurrency is set to 0. Otherwise we would look + * ahead pinning many buffers for no benefit, as the advice-based + * readahead doesn't support direct I/O. */ - if (io_direct_flags & IO_DIRECT_DATA) + if (io_method == IOMETHOD_SYNC && (io_direct_flags & IO_DIRECT_DATA)) max_ios = 0; /* Cap to INT16_MAX to avoid overflowing below */ @@ -641,15 +653,19 @@ read_stream_begin_impl(int flags, stream->per_buffer_data = (void *) MAXALIGN(&stream->ios[Max(1, max_ios)]); + stream->sync_mode = io_method == IOMETHOD_SYNC; + #ifdef USE_PREFETCH /* - * This system supports prefetching advice. We can use it as long as - * direct I/O isn't enabled, the caller hasn't promised sequential access - * (overriding our detection heuristics), and max_ios hasn't been set to - * zero. + * This system supports prefetching advice. + * + * Issue advice only if AIO is not used, direct I/O isn't enabled, the + * caller hasn't promised sequential access (overriding our detection + * heuristics), and max_ios hasn't been set to zero. */ - if ((io_direct_flags & IO_DIRECT_DATA) == 0 && + if (stream->sync_mode && + (io_direct_flags & IO_DIRECT_DATA) == 0 && (flags & READ_STREAM_SEQUENTIAL) == 0 && max_ios > 0) stream->advice_enabled = true; @@ -659,6 +675,9 @@ read_stream_begin_impl(int flags, * For now, max_ios = 0 is interpreted as max_ios = 1 with advice disabled * above. If we had real asynchronous I/O we might need a slightly * different definition. + * + * FIXME: Not sure what different definition we would need? I guess we + * could add the READ_BUFFERS_SYNCHRONOUSLY flag automatically? */ if (max_ios == 0) max_ios = 1; -- 2.48.1.76.g4e746b1a31.dirty --ow5flh3n247znjrs Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2.8-0027-aio-Experimental-heuristics-to-increase-batchin.patch" ^ permalink raw reply [nested|flat] 8+ messages in thread
* [PATCH v2.9 18/30] aio: Basic read_stream adjustments for real AIO @ 2025-03-15 16:29 Andres Freund <andres@anarazel.de> 0 siblings, 0 replies; 8+ messages in thread From: Andres Freund @ 2025-03-15 16:29 UTC (permalink / raw) Adapt the read stream logic for real AIO: - If AIO is enabled, we shouldn't issue advice, but if it isn't, we should continue issuing advice - AIO benefits from reading ahead with direct IO - While in read_stream_look_ahead(), we can use AIO batch submission mode for increased efficiency There is one comment talking about max_ios logic with "real asynchronous I/O" that I am not sure about, so I left it alone for now. There are further improvements we should consider, e.g. waiting to issue IOs until we can issue multiple IOs at once. But that's left for a future change, since it would involve additional heuristics. --- src/backend/storage/aio/read_stream.c | 29 ++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/src/backend/storage/aio/read_stream.c b/src/backend/storage/aio/read_stream.c index cdf4b5a86a2..d7b395b86a3 100644 --- a/src/backend/storage/aio/read_stream.c +++ b/src/backend/storage/aio/read_stream.c @@ -72,6 +72,7 @@ #include "postgres.h" #include "miscadmin.h" +#include "storage/aio.h" #include "storage/fd.h" #include "storage/smgr.h" #include "storage/read_stream.h" @@ -99,6 +100,7 @@ struct ReadStream int16 pinned_buffers; int16 distance; int16 initialized_buffers; + bool sync_mode; bool advice_enabled; bool temporary; @@ -416,6 +418,13 @@ read_stream_start_pending_read(ReadStream *stream) static void read_stream_look_ahead(ReadStream *stream) { + /* + * Allow amortizing the cost of submitting IO over multiple IOs. This + * requires that we don't do any operations that could lead to a deadlock + * with staged-but-unsubmitted IO. + */ + pgaio_enter_batchmode(); + while (stream->ios_in_progress < stream->max_ios && stream->pinned_buffers + stream->pending_read_nblocks < stream->distance) { @@ -463,6 +472,7 @@ read_stream_look_ahead(ReadStream *stream) { /* We've hit the buffer or I/O limit. Rewind and stop here. */ read_stream_unget_block(stream, blocknum); + pgaio_exit_batchmode(); return; } } @@ -497,6 +507,8 @@ read_stream_look_ahead(ReadStream *stream) * time. */ Assert(stream->pinned_buffers > 0 || stream->distance == 0); + + pgaio_exit_batchmode(); } /* @@ -628,15 +640,19 @@ read_stream_begin_impl(int flags, stream->per_buffer_data = (void *) MAXALIGN(&stream->ios[Max(1, max_ios)]); + stream->sync_mode = io_method == IOMETHOD_SYNC; + #ifdef USE_PREFETCH /* - * This system supports prefetching advice. We can use it as long as - * direct I/O isn't enabled, the caller hasn't promised sequential access - * (overriding our detection heuristics), and max_ios hasn't been set to - * zero. + * This system supports prefetching advice. + * + * Issue advice only if AIO is not used, direct I/O isn't enabled, the + * caller hasn't promised sequential access (overriding our detection + * heuristics), and max_ios hasn't been set to zero. */ - if ((io_direct_flags & IO_DIRECT_DATA) == 0 && + if (stream->sync_mode && + (io_direct_flags & IO_DIRECT_DATA) == 0 && (flags & READ_STREAM_SEQUENTIAL) == 0 && max_ios > 0) stream->advice_enabled = true; @@ -646,6 +662,9 @@ read_stream_begin_impl(int flags, * For now, max_ios = 0 is interpreted as max_ios = 1 with advice disabled * above. If we had real asynchronous I/O we might need a slightly * different definition. + * + * FIXME: Not sure what different definition we would need? I guess we + * could add the READ_BUFFERS_SYNCHRONOUSLY flag automatically? */ if (max_ios == 0) max_ios = 1; -- 2.48.1.76.g4e746b1a31.dirty --23jbdfobqrqxnmx5 Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2.9-0019-aio-Experimental-heuristics-to-increase-batchin.patch" ^ permalink raw reply [nested|flat] 8+ messages in thread
* [PATCH v2.10 12/28] aio: Basic read_stream adjustments for real AIO @ 2025-03-18 18:40 Andres Freund <andres@anarazel.de> 0 siblings, 0 replies; 8+ messages in thread From: Andres Freund @ 2025-03-18 18:40 UTC (permalink / raw) Adapt the read stream logic for real AIO: - If AIO is enabled, we shouldn't issue advice, but if it isn't, we should continue issuing advice - AIO benefits from reading ahead with direct IO - While in read_stream_look_ahead(), we can use AIO batch submission mode for increased efficiency There is one comment talking about max_ios logic with "real asynchronous I/O" that I am not sure about, so I left it alone for now. There are further improvements we should consider, e.g. waiting to issue IOs until we can issue multiple IOs at once. But that's left for a future change, since it would involve additional heuristics. --- src/backend/storage/aio/read_stream.c | 29 ++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/src/backend/storage/aio/read_stream.c b/src/backend/storage/aio/read_stream.c index cdf4b5a86a2..d7b395b86a3 100644 --- a/src/backend/storage/aio/read_stream.c +++ b/src/backend/storage/aio/read_stream.c @@ -72,6 +72,7 @@ #include "postgres.h" #include "miscadmin.h" +#include "storage/aio.h" #include "storage/fd.h" #include "storage/smgr.h" #include "storage/read_stream.h" @@ -99,6 +100,7 @@ struct ReadStream int16 pinned_buffers; int16 distance; int16 initialized_buffers; + bool sync_mode; bool advice_enabled; bool temporary; @@ -416,6 +418,13 @@ read_stream_start_pending_read(ReadStream *stream) static void read_stream_look_ahead(ReadStream *stream) { + /* + * Allow amortizing the cost of submitting IO over multiple IOs. This + * requires that we don't do any operations that could lead to a deadlock + * with staged-but-unsubmitted IO. + */ + pgaio_enter_batchmode(); + while (stream->ios_in_progress < stream->max_ios && stream->pinned_buffers + stream->pending_read_nblocks < stream->distance) { @@ -463,6 +472,7 @@ read_stream_look_ahead(ReadStream *stream) { /* We've hit the buffer or I/O limit. Rewind and stop here. */ read_stream_unget_block(stream, blocknum); + pgaio_exit_batchmode(); return; } } @@ -497,6 +507,8 @@ read_stream_look_ahead(ReadStream *stream) * time. */ Assert(stream->pinned_buffers > 0 || stream->distance == 0); + + pgaio_exit_batchmode(); } /* @@ -628,15 +640,19 @@ read_stream_begin_impl(int flags, stream->per_buffer_data = (void *) MAXALIGN(&stream->ios[Max(1, max_ios)]); + stream->sync_mode = io_method == IOMETHOD_SYNC; + #ifdef USE_PREFETCH /* - * This system supports prefetching advice. We can use it as long as - * direct I/O isn't enabled, the caller hasn't promised sequential access - * (overriding our detection heuristics), and max_ios hasn't been set to - * zero. + * This system supports prefetching advice. + * + * Issue advice only if AIO is not used, direct I/O isn't enabled, the + * caller hasn't promised sequential access (overriding our detection + * heuristics), and max_ios hasn't been set to zero. */ - if ((io_direct_flags & IO_DIRECT_DATA) == 0 && + if (stream->sync_mode && + (io_direct_flags & IO_DIRECT_DATA) == 0 && (flags & READ_STREAM_SEQUENTIAL) == 0 && max_ios > 0) stream->advice_enabled = true; @@ -646,6 +662,9 @@ read_stream_begin_impl(int flags, * For now, max_ios = 0 is interpreted as max_ios = 1 with advice disabled * above. If we had real asynchronous I/O we might need a slightly * different definition. + * + * FIXME: Not sure what different definition we would need? I guess we + * could add the READ_BUFFERS_SYNCHRONOUSLY flag automatically? */ if (max_ios == 0) max_ios = 1; -- 2.48.1.76.g4e746b1a31.dirty --w6dfit2y42fwvotd Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2.10-0013-docs-Reframe-track_io_timing-related-docs-as-w.patch" ^ permalink raw reply [nested|flat] 8+ messages in thread
* [PATCH v2.11 13/27] aio: Basic read_stream adjustments for real AIO @ 2025-03-18 18:40 Andres Freund <andres@anarazel.de> 0 siblings, 0 replies; 8+ messages in thread From: Andres Freund @ 2025-03-18 18:40 UTC (permalink / raw) Adapt the read stream logic for real AIO: - If AIO is enabled, we shouldn't issue advice, but if it isn't, we should continue issuing advice - AIO benefits from reading ahead with direct IO - While in read_stream_look_ahead(), we can use AIO batch submission mode for increased efficiency There is one comment talking about max_ios logic with "real asynchronous I/O" that I am not sure about, so I left it alone for now. There are further improvements we should consider, e.g. waiting to issue IOs until we can issue multiple IOs at once. But that's left for a future change, since it would involve additional heuristics. --- src/backend/storage/aio/read_stream.c | 29 ++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/src/backend/storage/aio/read_stream.c b/src/backend/storage/aio/read_stream.c index 18ecf4affc7..60a841816d8 100644 --- a/src/backend/storage/aio/read_stream.c +++ b/src/backend/storage/aio/read_stream.c @@ -72,6 +72,7 @@ #include "postgres.h" #include "miscadmin.h" +#include "storage/aio.h" #include "storage/fd.h" #include "storage/smgr.h" #include "storage/read_stream.h" @@ -99,6 +100,7 @@ struct ReadStream int16 pinned_buffers; int16 distance; int16 initialized_buffers; + bool sync_mode; bool advice_enabled; bool temporary; @@ -416,6 +418,13 @@ read_stream_start_pending_read(ReadStream *stream) static void read_stream_look_ahead(ReadStream *stream) { + /* + * Allow amortizing the cost of submitting IO over multiple IOs. This + * requires that we don't do any operations that could lead to a deadlock + * with staged-but-unsubmitted IO. + */ + pgaio_enter_batchmode(); + while (stream->ios_in_progress < stream->max_ios && stream->pinned_buffers + stream->pending_read_nblocks < stream->distance) { @@ -463,6 +472,7 @@ read_stream_look_ahead(ReadStream *stream) { /* We've hit the buffer or I/O limit. Rewind and stop here. */ read_stream_unget_block(stream, blocknum); + pgaio_exit_batchmode(); return; } } @@ -497,6 +507,8 @@ read_stream_look_ahead(ReadStream *stream) * time. */ Assert(stream->pinned_buffers > 0 || stream->distance == 0); + + pgaio_exit_batchmode(); } /* @@ -629,15 +641,19 @@ read_stream_begin_impl(int flags, stream->per_buffer_data = (void *) MAXALIGN(&stream->ios[Max(1, max_ios)]); + stream->sync_mode = io_method == IOMETHOD_SYNC; + #ifdef USE_PREFETCH /* - * This system supports prefetching advice. We can use it as long as - * direct I/O isn't enabled, the caller hasn't promised sequential access - * (overriding our detection heuristics), and max_ios hasn't been set to - * zero. + * This system supports prefetching advice. + * + * Issue advice only if AIO is not used, direct I/O isn't enabled, the + * caller hasn't promised sequential access (overriding our detection + * heuristics), and max_ios hasn't been set to zero. */ - if ((io_direct_flags & IO_DIRECT_DATA) == 0 && + if (stream->sync_mode && + (io_direct_flags & IO_DIRECT_DATA) == 0 && (flags & READ_STREAM_SEQUENTIAL) == 0 && max_ios > 0) stream->advice_enabled = true; @@ -647,6 +663,9 @@ read_stream_begin_impl(int flags, * For now, max_ios = 0 is interpreted as max_ios = 1 with advice disabled * above. If we had real asynchronous I/O we might need a slightly * different definition. + * + * FIXME: Not sure what different definition we would need? I guess we + * could add the READ_BUFFERS_SYNCHRONOUSLY flag automatically? */ if (max_ios == 0) max_ios = 1; -- 2.48.1.76.g4e746b1a31.dirty --bjnmbpad43bpmfxt Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2.11-0014-docs-Reframe-track_io_timing-related-docs-as-w.patch" ^ permalink raw reply [nested|flat] 8+ messages in thread
* [PATCH v2.12 10/28] aio: Basic read_stream adjustments for real AIO @ 2025-03-18 18:40 Andres Freund <andres@anarazel.de> 0 siblings, 0 replies; 8+ messages in thread From: Andres Freund @ 2025-03-18 18:40 UTC (permalink / raw) Adapt the read stream logic for real AIO: - If AIO is enabled, we shouldn't issue advice, but if it isn't, we should continue issuing advice - AIO benefits from reading ahead with direct IO There is one comment talking about max_ios logic with "real asynchronous I/O" that I am not sure about, so I left it alone for now. There are further improvements we should consider: - While in read_stream_look_ahead(), we can use AIO batch submission mode for increased efficiency - We could wait to issue IOs until we can issue multiple IOs at once --- src/backend/storage/aio/read_stream.c | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/src/backend/storage/aio/read_stream.c b/src/backend/storage/aio/read_stream.c index c60e37e7f7f..df16530d673 100644 --- a/src/backend/storage/aio/read_stream.c +++ b/src/backend/storage/aio/read_stream.c @@ -72,6 +72,7 @@ #include "postgres.h" #include "miscadmin.h" +#include "storage/aio.h" #include "storage/fd.h" #include "storage/smgr.h" #include "storage/read_stream.h" @@ -99,6 +100,7 @@ struct ReadStream int16 pinned_buffers; int16 distance; int16 initialized_buffers; + bool sync_mode; /* using io_method=sync */ bool advice_enabled; bool temporary; @@ -613,15 +615,19 @@ read_stream_begin_impl(int flags, stream->per_buffer_data = (void *) MAXALIGN(&stream->ios[Max(1, max_ios)]); + stream->sync_mode = io_method == IOMETHOD_SYNC; + #ifdef USE_PREFETCH /* - * This system supports prefetching advice. We can use it as long as - * direct I/O isn't enabled, the caller hasn't promised sequential access - * (overriding our detection heuristics), and max_ios hasn't been set to - * zero. + * This system supports prefetching advice. + * + * Issue advice only if AIO is not used, direct I/O isn't enabled, the + * caller hasn't promised sequential access (overriding our detection + * heuristics), and max_ios hasn't been set to zero. */ - if ((io_direct_flags & IO_DIRECT_DATA) == 0 && + if (stream->sync_mode && + (io_direct_flags & IO_DIRECT_DATA) == 0 && (flags & READ_STREAM_SEQUENTIAL) == 0 && max_ios > 0) stream->advice_enabled = true; @@ -631,6 +637,9 @@ read_stream_begin_impl(int flags, * For now, max_ios = 0 is interpreted as max_ios = 1 with advice disabled * above. If we had real asynchronous I/O we might need a slightly * different definition. + * + * FIXME: Not sure what different definition we would need? I guess we + * could add the READ_BUFFERS_SYNCHRONOUSLY flag automatically? */ if (max_ios == 0) max_ios = 1; -- 2.48.1.76.g4e746b1a31.dirty --5i73spx2p4vwf7fe Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2.12-0011-read_stream-Introduce-and-use-optional-batchmo.patch" ^ permalink raw reply [nested|flat] 8+ messages in thread
* [PATCH v2.13 13/28] aio: Basic read_stream adjustments for real AIO @ 2025-03-18 18:40 Andres Freund <andres@anarazel.de> 0 siblings, 0 replies; 8+ messages in thread From: Andres Freund @ 2025-03-18 18:40 UTC (permalink / raw) Adapt the read stream logic for real AIO: - If AIO is enabled, we shouldn't issue advice, but if it isn't, we should continue issuing advice - AIO benefits from reading ahead with direct IO - If effective_io_concurrency=0, pass READ_BUFFERS_SYNCHRONOUSLY to StartReadBuffers() to ensure synchronous IO execution There are further improvements we should consider: - While in read_stream_look_ahead(), we can use AIO batch submission mode for increased efficiency. That however requires care to avoid deadlocks and thus done separately. - It can be beneficial to defer starting new IOs until we can issue multiple IOs at once. That however requires non-trivial heuristics to decide when to do so. Co-authored-by: Andres Freund <andres@anarazel.de> Co-authored-by: Thomas Munro <thomas.munro@gmail.com> --- src/backend/storage/aio/read_stream.c | 39 ++++++++++++++++++--------- 1 file changed, 26 insertions(+), 13 deletions(-) diff --git a/src/backend/storage/aio/read_stream.c b/src/backend/storage/aio/read_stream.c index c60e37e7f7f..26e5dfe77db 100644 --- a/src/backend/storage/aio/read_stream.c +++ b/src/backend/storage/aio/read_stream.c @@ -72,6 +72,7 @@ #include "postgres.h" #include "miscadmin.h" +#include "storage/aio.h" #include "storage/fd.h" #include "storage/smgr.h" #include "storage/read_stream.h" @@ -99,6 +100,8 @@ struct ReadStream int16 pinned_buffers; int16 distance; int16 initialized_buffers; + int read_buffers_flags; + bool sync_mode; /* using io_method=sync */ bool advice_enabled; bool temporary; @@ -250,7 +253,7 @@ read_stream_start_pending_read(ReadStream *stream) Assert(stream->next_buffer_index == stream->oldest_buffer_index); /* Do we need to issue read-ahead advice? */ - flags = 0; + flags = stream->read_buffers_flags; if (stream->advice_enabled) { if (stream->pending_read_blocknum == stream->seq_blocknum) @@ -261,7 +264,7 @@ read_stream_start_pending_read(ReadStream *stream) * then stay of the way of the kernel's own read-ahead. */ if (stream->seq_until_processed != InvalidBlockNumber) - flags = READ_BUFFERS_ISSUE_ADVICE; + flags |= READ_BUFFERS_ISSUE_ADVICE; } else { @@ -272,7 +275,7 @@ read_stream_start_pending_read(ReadStream *stream) */ stream->seq_until_processed = stream->pending_read_blocknum; if (stream->pinned_buffers > 0) - flags = READ_BUFFERS_ISSUE_ADVICE; + flags |= READ_BUFFERS_ISSUE_ADVICE; } } @@ -613,27 +616,33 @@ read_stream_begin_impl(int flags, stream->per_buffer_data = (void *) MAXALIGN(&stream->ios[Max(1, max_ios)]); + stream->sync_mode = io_method == IOMETHOD_SYNC; + #ifdef USE_PREFETCH /* - * This system supports prefetching advice. We can use it as long as - * direct I/O isn't enabled, the caller hasn't promised sequential access - * (overriding our detection heuristics), and max_ios hasn't been set to - * zero. + * Read-ahead advice simulating asynchronous I/O with synchronous calls. + * Issue advice only if AIO is not used, direct I/O isn't enabled, the + * caller hasn't promised sequential access (overriding our detection + * heuristics), and max_ios hasn't been set to zero. */ - if ((io_direct_flags & IO_DIRECT_DATA) == 0 && + if (stream->sync_mode && + (io_direct_flags & IO_DIRECT_DATA) == 0 && (flags & READ_STREAM_SEQUENTIAL) == 0 && max_ios > 0) stream->advice_enabled = true; #endif /* - * For now, max_ios = 0 is interpreted as max_ios = 1 with advice disabled - * above. If we had real asynchronous I/O we might need a slightly - * different definition. + * Setting max_ios to zero disables AIO and advice-based pseudo AIO, but + * we still need to allocate space to combine and run one I/O. Bump it up + * to one, and remember to ask for synchronous I/O only. */ if (max_ios == 0) + { max_ios = 1; + stream->read_buffers_flags = READ_BUFFERS_SYNCHRONOUSLY; + } /* * Capture stable values for these two GUC-derived numbers for the @@ -777,6 +786,11 @@ read_stream_next_buffer(ReadStream *stream, void **per_buffer_data) if (likely(next_blocknum != InvalidBlockNumber)) { + int flags = stream->read_buffers_flags; + + if (stream->advice_enabled) + flags |= READ_BUFFERS_ISSUE_ADVICE; + /* * Pin a buffer for the next call. Same buffer entry, and * arbitrary I/O entry (they're all free). We don't have to @@ -792,8 +806,7 @@ read_stream_next_buffer(ReadStream *stream, void **per_buffer_data) if (likely(!StartReadBuffer(&stream->ios[0].op, &stream->buffers[oldest_buffer_index], next_blocknum, - stream->advice_enabled ? - READ_BUFFERS_ISSUE_ADVICE : 0))) + flags))) { /* Fast return. */ return buffer; -- 2.48.1.76.g4e746b1a31.dirty --pro7bqageygxfsvg Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2.13-0014-read_stream-Introduce-and-use-optional-batchmo.patch" ^ permalink raw reply [nested|flat] 8+ messages in thread
* [PATCH v2.14 14/29] aio: Basic read_stream adjustments for real AIO @ 2025-03-18 18:40 Andres Freund <andres@anarazel.de> 0 siblings, 0 replies; 8+ messages in thread From: Andres Freund @ 2025-03-18 18:40 UTC (permalink / raw) Adapt the read stream logic for real AIO: - If AIO is enabled, we shouldn't issue advice, but if it isn't, we should continue issuing advice - AIO benefits from reading ahead with direct IO - If effective_io_concurrency=0, pass READ_BUFFERS_SYNCHRONOUSLY to StartReadBuffers() to ensure synchronous IO execution There are further improvements we should consider: - While in read_stream_look_ahead(), we can use AIO batch submission mode for increased efficiency. That however requires care to avoid deadlocks and thus done separately. - It can be beneficial to defer starting new IOs until we can issue multiple IOs at once. That however requires non-trivial heuristics to decide when to do so. Co-authored-by: Andres Freund <andres@anarazel.de> Co-authored-by: Thomas Munro <thomas.munro@gmail.com> --- src/backend/storage/aio/read_stream.c | 39 ++++++++++++++++++--------- 1 file changed, 26 insertions(+), 13 deletions(-) diff --git a/src/backend/storage/aio/read_stream.c b/src/backend/storage/aio/read_stream.c index c60e37e7f7f..26e5dfe77db 100644 --- a/src/backend/storage/aio/read_stream.c +++ b/src/backend/storage/aio/read_stream.c @@ -72,6 +72,7 @@ #include "postgres.h" #include "miscadmin.h" +#include "storage/aio.h" #include "storage/fd.h" #include "storage/smgr.h" #include "storage/read_stream.h" @@ -99,6 +100,8 @@ struct ReadStream int16 pinned_buffers; int16 distance; int16 initialized_buffers; + int read_buffers_flags; + bool sync_mode; /* using io_method=sync */ bool advice_enabled; bool temporary; @@ -250,7 +253,7 @@ read_stream_start_pending_read(ReadStream *stream) Assert(stream->next_buffer_index == stream->oldest_buffer_index); /* Do we need to issue read-ahead advice? */ - flags = 0; + flags = stream->read_buffers_flags; if (stream->advice_enabled) { if (stream->pending_read_blocknum == stream->seq_blocknum) @@ -261,7 +264,7 @@ read_stream_start_pending_read(ReadStream *stream) * then stay of the way of the kernel's own read-ahead. */ if (stream->seq_until_processed != InvalidBlockNumber) - flags = READ_BUFFERS_ISSUE_ADVICE; + flags |= READ_BUFFERS_ISSUE_ADVICE; } else { @@ -272,7 +275,7 @@ read_stream_start_pending_read(ReadStream *stream) */ stream->seq_until_processed = stream->pending_read_blocknum; if (stream->pinned_buffers > 0) - flags = READ_BUFFERS_ISSUE_ADVICE; + flags |= READ_BUFFERS_ISSUE_ADVICE; } } @@ -613,27 +616,33 @@ read_stream_begin_impl(int flags, stream->per_buffer_data = (void *) MAXALIGN(&stream->ios[Max(1, max_ios)]); + stream->sync_mode = io_method == IOMETHOD_SYNC; + #ifdef USE_PREFETCH /* - * This system supports prefetching advice. We can use it as long as - * direct I/O isn't enabled, the caller hasn't promised sequential access - * (overriding our detection heuristics), and max_ios hasn't been set to - * zero. + * Read-ahead advice simulating asynchronous I/O with synchronous calls. + * Issue advice only if AIO is not used, direct I/O isn't enabled, the + * caller hasn't promised sequential access (overriding our detection + * heuristics), and max_ios hasn't been set to zero. */ - if ((io_direct_flags & IO_DIRECT_DATA) == 0 && + if (stream->sync_mode && + (io_direct_flags & IO_DIRECT_DATA) == 0 && (flags & READ_STREAM_SEQUENTIAL) == 0 && max_ios > 0) stream->advice_enabled = true; #endif /* - * For now, max_ios = 0 is interpreted as max_ios = 1 with advice disabled - * above. If we had real asynchronous I/O we might need a slightly - * different definition. + * Setting max_ios to zero disables AIO and advice-based pseudo AIO, but + * we still need to allocate space to combine and run one I/O. Bump it up + * to one, and remember to ask for synchronous I/O only. */ if (max_ios == 0) + { max_ios = 1; + stream->read_buffers_flags = READ_BUFFERS_SYNCHRONOUSLY; + } /* * Capture stable values for these two GUC-derived numbers for the @@ -777,6 +786,11 @@ read_stream_next_buffer(ReadStream *stream, void **per_buffer_data) if (likely(next_blocknum != InvalidBlockNumber)) { + int flags = stream->read_buffers_flags; + + if (stream->advice_enabled) + flags |= READ_BUFFERS_ISSUE_ADVICE; + /* * Pin a buffer for the next call. Same buffer entry, and * arbitrary I/O entry (they're all free). We don't have to @@ -792,8 +806,7 @@ read_stream_next_buffer(ReadStream *stream, void **per_buffer_data) if (likely(!StartReadBuffer(&stream->ios[0].op, &stream->buffers[oldest_buffer_index], next_blocknum, - stream->advice_enabled ? - READ_BUFFERS_ISSUE_ADVICE : 0))) + flags))) { /* Fast return. */ return buffer; -- 2.48.1.76.g4e746b1a31.dirty --m2na7lgr3zfazgom Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2.14-0015-read_stream-Introduce-and-use-optional-batchmo.patch" ^ permalink raw reply [nested|flat] 8+ messages in thread
end of thread, other threads:[~2025-03-18 18:40 UTC | newest] Thread overview: 8+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2021-04-04 00:24 [PATCH v3 3/3] Change force_parallel_mode to a DEVELOPER GUC, and remove it from sample config.. Justin Pryzby <pryzbyj@telsasoft.com> 2025-03-14 15:39 [PATCH v2.8 26/38] aio: Basic read_stream adjustments for real AIO Andres Freund <andres@anarazel.de> 2025-03-15 16:29 [PATCH v2.9 18/30] aio: Basic read_stream adjustments for real AIO Andres Freund <andres@anarazel.de> 2025-03-18 18:40 [PATCH v2.10 12/28] aio: Basic read_stream adjustments for real AIO Andres Freund <andres@anarazel.de> 2025-03-18 18:40 [PATCH v2.11 13/27] aio: Basic read_stream adjustments for real AIO Andres Freund <andres@anarazel.de> 2025-03-18 18:40 [PATCH v2.12 10/28] aio: Basic read_stream adjustments for real AIO Andres Freund <andres@anarazel.de> 2025-03-18 18:40 [PATCH v2.13 13/28] aio: Basic read_stream adjustments for real AIO Andres Freund <andres@anarazel.de> 2025-03-18 18:40 [PATCH v2.14 14/29] aio: Basic read_stream adjustments for real AIO Andres Freund <andres@anarazel.de>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox