pg.ddx.io pgsql-committers@postgresql.org mailing list archivehelp / color / mirror / Atom feed
pgsql: Fix broken snapshot handling in parallel workers. 6+ messages / 1 participants [nested] [flat]
* pgsql: Fix broken snapshot handling in parallel workers. @ 2021-08-25 13:31 Robert Haas <rhaas@postgresql.org> 0 siblings, 0 replies; 6+ messages in thread From: Robert Haas @ 2021-08-25 13:31 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix broken snapshot handling in parallel workers. Pengchengliu reported an assertion failure in a parallel woker while performing a parallel scan using an overflowed snapshot. The proximate cause is that TransactionXmin was set to an incorrect value. The underlying cause is incorrect snapshot handling in parallel.c. In particular, InitializeParallelDSM() was unconditionally calling GetTransactionSnapshot(), because I (rhaas) mistakenly thought that was always retrieving an existing snapshot whereas, at isolation levels less than REPEATABLE READ, it's actually taking a new one. So instead do this only at higher isolation levels where there actually is a single snapshot for the whole transaction. By itself, this is not a sufficient fix, because we still need to guarantee that TransactionXmin gets set properly in the workers. The easiest way to do that seems to be to install the leader's active snapshot as the transaction snapshot if the leader did not serialize a transaction snapshot. This doesn't affect the results of future GetTrasnactionSnapshot() calls since those have to take a new snapshot anyway; what we care about is the side effect of setting TransactionXmin. Report by Pengchengliu. Patch by Greg Nancarrow, except for some comment text which I supplied. Discussion: https://postgr.es/m/002f01d748ac$eaa781a0$bff684e0$@tju.edu.cn Branch ------ master Details ------- https://git.postgresql.org/pg/commitdiff/a780b2fcce6cf45462946fffcd84021a4d1429c8 Modified Files -------------- src/backend/access/transam/parallel.c | 52 +++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 14 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix broken snapshot handling in parallel workers. @ 2021-08-25 13:31 Robert Haas <rhaas@postgresql.org> 0 siblings, 0 replies; 6+ messages in thread From: Robert Haas @ 2021-08-25 13:31 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix broken snapshot handling in parallel workers. Pengchengliu reported an assertion failure in a parallel woker while performing a parallel scan using an overflowed snapshot. The proximate cause is that TransactionXmin was set to an incorrect value. The underlying cause is incorrect snapshot handling in parallel.c. In particular, InitializeParallelDSM() was unconditionally calling GetTransactionSnapshot(), because I (rhaas) mistakenly thought that was always retrieving an existing snapshot whereas, at isolation levels less than REPEATABLE READ, it's actually taking a new one. So instead do this only at higher isolation levels where there actually is a single snapshot for the whole transaction. By itself, this is not a sufficient fix, because we still need to guarantee that TransactionXmin gets set properly in the workers. The easiest way to do that seems to be to install the leader's active snapshot as the transaction snapshot if the leader did not serialize a transaction snapshot. This doesn't affect the results of future GetTrasnactionSnapshot() calls since those have to take a new snapshot anyway; what we care about is the side effect of setting TransactionXmin. Report by Pengchengliu. Patch by Greg Nancarrow, except for some comment text which I supplied. Discussion: https://postgr.es/m/002f01d748ac$eaa781a0$bff684e0$@tju.edu.cn Branch ------ REL_14_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/11c1239881b399d1fe87186f1f8a10a505d4a692 Modified Files -------------- src/backend/access/transam/parallel.c | 52 +++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 14 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix broken snapshot handling in parallel workers. @ 2021-08-25 13:31 Robert Haas <rhaas@postgresql.org> 0 siblings, 0 replies; 6+ messages in thread From: Robert Haas @ 2021-08-25 13:31 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix broken snapshot handling in parallel workers. Pengchengliu reported an assertion failure in a parallel woker while performing a parallel scan using an overflowed snapshot. The proximate cause is that TransactionXmin was set to an incorrect value. The underlying cause is incorrect snapshot handling in parallel.c. In particular, InitializeParallelDSM() was unconditionally calling GetTransactionSnapshot(), because I (rhaas) mistakenly thought that was always retrieving an existing snapshot whereas, at isolation levels less than REPEATABLE READ, it's actually taking a new one. So instead do this only at higher isolation levels where there actually is a single snapshot for the whole transaction. By itself, this is not a sufficient fix, because we still need to guarantee that TransactionXmin gets set properly in the workers. The easiest way to do that seems to be to install the leader's active snapshot as the transaction snapshot if the leader did not serialize a transaction snapshot. This doesn't affect the results of future GetTrasnactionSnapshot() calls since those have to take a new snapshot anyway; what we care about is the side effect of setting TransactionXmin. Report by Pengchengliu. Patch by Greg Nancarrow, except for some comment text which I supplied. Discussion: https://postgr.es/m/002f01d748ac$eaa781a0$bff684e0$@tju.edu.cn Branch ------ REL_13_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/bc062cb938234d8e815d14fecd8d3b2abff3fe88 Modified Files -------------- src/backend/access/transam/parallel.c | 52 +++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 14 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix broken snapshot handling in parallel workers. @ 2021-08-25 13:31 Robert Haas <rhaas@postgresql.org> 0 siblings, 0 replies; 6+ messages in thread From: Robert Haas @ 2021-08-25 13:31 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix broken snapshot handling in parallel workers. Pengchengliu reported an assertion failure in a parallel woker while performing a parallel scan using an overflowed snapshot. The proximate cause is that TransactionXmin was set to an incorrect value. The underlying cause is incorrect snapshot handling in parallel.c. In particular, InitializeParallelDSM() was unconditionally calling GetTransactionSnapshot(), because I (rhaas) mistakenly thought that was always retrieving an existing snapshot whereas, at isolation levels less than REPEATABLE READ, it's actually taking a new one. So instead do this only at higher isolation levels where there actually is a single snapshot for the whole transaction. By itself, this is not a sufficient fix, because we still need to guarantee that TransactionXmin gets set properly in the workers. The easiest way to do that seems to be to install the leader's active snapshot as the transaction snapshot if the leader did not serialize a transaction snapshot. This doesn't affect the results of future GetTrasnactionSnapshot() calls since those have to take a new snapshot anyway; what we care about is the side effect of setting TransactionXmin. Report by Pengchengliu. Patch by Greg Nancarrow, except for some comment text which I supplied. Discussion: https://postgr.es/m/002f01d748ac$eaa781a0$bff684e0$@tju.edu.cn Branch ------ REL_12_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/f4b77e82ebf44f5cbe9b9ddda5688422853c75d3 Modified Files -------------- src/backend/access/transam/parallel.c | 52 +++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 14 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix broken snapshot handling in parallel workers. @ 2021-08-25 13:31 Robert Haas <rhaas@postgresql.org> 0 siblings, 0 replies; 6+ messages in thread From: Robert Haas @ 2021-08-25 13:31 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix broken snapshot handling in parallel workers. Pengchengliu reported an assertion failure in a parallel woker while performing a parallel scan using an overflowed snapshot. The proximate cause is that TransactionXmin was set to an incorrect value. The underlying cause is incorrect snapshot handling in parallel.c. In particular, InitializeParallelDSM() was unconditionally calling GetTransactionSnapshot(), because I (rhaas) mistakenly thought that was always retrieving an existing snapshot whereas, at isolation levels less than REPEATABLE READ, it's actually taking a new one. So instead do this only at higher isolation levels where there actually is a single snapshot for the whole transaction. By itself, this is not a sufficient fix, because we still need to guarantee that TransactionXmin gets set properly in the workers. The easiest way to do that seems to be to install the leader's active snapshot as the transaction snapshot if the leader did not serialize a transaction snapshot. This doesn't affect the results of future GetTrasnactionSnapshot() calls since those have to take a new snapshot anyway; what we care about is the side effect of setting TransactionXmin. Report by Pengchengliu. Patch by Greg Nancarrow, except for some comment text which I supplied. Discussion: https://postgr.es/m/002f01d748ac$eaa781a0$bff684e0$@tju.edu.cn Branch ------ REL_11_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/198cf81e2c64bdf2d4fa3c24d54c1eacf47a3d38 Modified Files -------------- src/backend/access/transam/parallel.c | 52 +++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 14 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix broken snapshot handling in parallel workers. @ 2021-08-25 13:31 Robert Haas <rhaas@postgresql.org> 0 siblings, 0 replies; 6+ messages in thread From: Robert Haas @ 2021-08-25 13:31 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix broken snapshot handling in parallel workers. Pengchengliu reported an assertion failure in a parallel woker while performing a parallel scan using an overflowed snapshot. The proximate cause is that TransactionXmin was set to an incorrect value. The underlying cause is incorrect snapshot handling in parallel.c. In particular, InitializeParallelDSM() was unconditionally calling GetTransactionSnapshot(), because I (rhaas) mistakenly thought that was always retrieving an existing snapshot whereas, at isolation levels less than REPEATABLE READ, it's actually taking a new one. So instead do this only at higher isolation levels where there actually is a single snapshot for the whole transaction. By itself, this is not a sufficient fix, because we still need to guarantee that TransactionXmin gets set properly in the workers. The easiest way to do that seems to be to install the leader's active snapshot as the transaction snapshot if the leader did not serialize a transaction snapshot. This doesn't affect the results of future GetTrasnactionSnapshot() calls since those have to take a new snapshot anyway; what we care about is the side effect of setting TransactionXmin. Report by Pengchengliu. Patch by Greg Nancarrow, except for some comment text which I supplied. Discussion: https://postgr.es/m/002f01d748ac$eaa781a0$bff684e0$@tju.edu.cn Branch ------ REL_10_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/96f6ef9fe451aa07d0b9b744f41482e52bdd1b8a Modified Files -------------- src/backend/access/transam/parallel.c | 52 +++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 14 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
end of thread, other threads:[~2021-08-25 13:31 UTC | newest] Thread overview: 6+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2021-08-25 13:31 pgsql: Fix broken snapshot handling in parallel workers. Robert Haas <rhaas@postgresql.org> 2021-08-25 13:31 pgsql: Fix broken snapshot handling in parallel workers. Robert Haas <rhaas@postgresql.org> 2021-08-25 13:31 pgsql: Fix broken snapshot handling in parallel workers. Robert Haas <rhaas@postgresql.org> 2021-08-25 13:31 pgsql: Fix broken snapshot handling in parallel workers. Robert Haas <rhaas@postgresql.org> 2021-08-25 13:31 pgsql: Fix broken snapshot handling in parallel workers. Robert Haas <rhaas@postgresql.org> 2021-08-25 13:31 pgsql: Fix broken snapshot handling in parallel workers. Robert Haas <rhaas@postgresql.org>
This inbox is served by DDX for PostgreSQL; see mirroring instructions for how to clone and mirror all data and code used for this inbox