explain analyze output with parallel workers - question about meaning of information for explain.depesz.com

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index 53c5254..6a6bf20 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -919,14 +919,25 @@ ExecParallelRetrieveInstrumentation(PlanState *planstate,
 	 * regular instrumentation information, which is the per-query context.
 	 * Switch into per-query memory context.
 	 */
-	oldcontext = MemoryContextSwitchTo(planstate->state->es_query_cxt);
-	ibytes = mul_size(instrumentation->num_workers, sizeof(Instrumentation));
-	planstate->worker_instrument =
-		palloc(ibytes + offsetof(WorkerInstrumentation, instrument));
-	MemoryContextSwitchTo(oldcontext);
+	if (!planstate->worker_instrument)
+	{
+		oldcontext = MemoryContextSwitchTo(planstate->state->es_query_cxt);
+		ibytes = mul_size(instrumentation->num_workers, sizeof(Instrumentation));
+		planstate->worker_instrument =
+			palloc(ibytes + offsetof(WorkerInstrumentation, instrument));
+		MemoryContextSwitchTo(oldcontext);
+
+		for (n = 0; n < instrumentation->num_workers; ++n)
+			InstrInit(&planstate->worker_instrument->instrument[n],
+					  planstate->state->es_instrument);
+	}
 
 	planstate->worker_instrument->num_workers = instrumentation->num_workers;
-	memcpy(&planstate->worker_instrument->instrument, instrument, ibytes);
+
+	/* Accumulate the per-worker detail. */
+	for (n = 0; n < instrumentation->num_workers; ++n)
+		InstrAggNode(&planstate->worker_instrument->instrument[n],
+					 &instrument[n]);
 
 	/*
 	 * Perform any node-type-specific work that needs to be done.  Currently,
@@ -989,8 +1000,20 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 
 	/* Finally, accumulate instrumentation, if any. */
 	if (pei->instrumentation)
+	{
+		Instrumentation *instrument;
+		SharedExecutorInstrumentation *sh_instr;
+
+		sh_instr = pei->instrumentation;
+
 		ExecParallelRetrieveInstrumentation(pei->planstate,
-											pei->instrumentation);
+											sh_instr);
+
+		/* Clear the instrumentation space for next time. */
+		instrument = GetInstrumentationArray(sh_instr);
+		for (i = 0; i < sh_instr->num_workers * sh_instr->num_plan_nodes; ++i)
+			InstrInit(&instrument[i], pei->planstate->state->es_instrument);
+	}
 
 	pei->finished = true;
 }

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index 53c5254..6a6bf20 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -919,14 +919,25 @@ ExecParallelRetrieveInstrumentation(PlanState *planstate,
 	 * regular instrumentation information, which is the per-query context.
 	 * Switch into per-query memory context.
 	 */
-	oldcontext = MemoryContextSwitchTo(planstate->state->es_query_cxt);
-	ibytes = mul_size(instrumentation->num_workers, sizeof(Instrumentation));
-	planstate->worker_instrument =
-		palloc(ibytes + offsetof(WorkerInstrumentation, instrument));
-	MemoryContextSwitchTo(oldcontext);
+	if (!planstate->worker_instrument)
+	{
+		oldcontext = MemoryContextSwitchTo(planstate->state->es_query_cxt);
+		ibytes = mul_size(instrumentation->num_workers, sizeof(Instrumentation));
+		planstate->worker_instrument =
+			palloc(ibytes + offsetof(WorkerInstrumentation, instrument));
+		MemoryContextSwitchTo(oldcontext);
+
+		for (n = 0; n < instrumentation->num_workers; ++n)
+			InstrInit(&planstate->worker_instrument->instrument[n],
+					  planstate->state->es_instrument);
+	}
 
 	planstate->worker_instrument->num_workers = instrumentation->num_workers;
-	memcpy(&planstate->worker_instrument->instrument, instrument, ibytes);
+
+	/* Accumulate the per-worker detail. */
+	for (n = 0; n < instrumentation->num_workers; ++n)
+		InstrAggNode(&planstate->worker_instrument->instrument[n],
+					 &instrument[n]);
 
 	/*
 	 * Perform any node-type-specific work that needs to be done.  Currently,
@@ -989,8 +1000,20 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 
 	/* Finally, accumulate instrumentation, if any. */
 	if (pei->instrumentation)
+	{
+		Instrumentation *instrument;
+		SharedExecutorInstrumentation *sh_instr;
+
+		sh_instr = pei->instrumentation;
+
 		ExecParallelRetrieveInstrumentation(pei->planstate,
-											pei->instrumentation);
+											sh_instr);
+
+		/* Clear the instrumentation space for next time. */
+		instrument = GetInstrumentationArray(sh_instr);
+		for (i = 0; i < sh_instr->num_workers * sh_instr->num_plan_nodes; ++i)
+			InstrInit(&instrument[i], pei->planstate->state->es_instrument);
+	}
 
 	pei->finished = true;
 }
diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out
index d1d5b22..681f84a 100644
--- a/src/test/regress/expected/select_parallel.out
+++ b/src/test/regress/expected/select_parallel.out
@@ -378,7 +378,27 @@ select count(*) from bmscantest where a>1;
  99999
 (1 row)
 
+-- test accumulation of stats for parallel node
 reset enable_seqscan;
+alter table tenk2 set (parallel_workers = 0);
+explain (analyze, timing off, summary off, costs off)
+	select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0; 
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
+ Aggregate (actual rows=1 loops=1)
+   ->  Nested Loop (actual rows=98000 loops=1)
+         ->  Seq Scan on tenk2 (actual rows=10 loops=1)
+               Filter: (thousand = 0)
+               Rows Removed by Filter: 9990
+         ->  Gather (actual rows=9800 loops=10)
+               Workers Planned: 4
+               Workers Launched: 4
+               ->  Parallel Seq Scan on tenk1 (actual rows=1960 loops=50)
+                     Filter: (hundred > 1)
+                     Rows Removed by Filter: 40
+(11 rows)
+
+alter table tenk2 reset (parallel_workers);
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;
diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql
index bb4e34a..0c7353f 100644
--- a/src/test/regress/sql/select_parallel.sql
+++ b/src/test/regress/sql/select_parallel.sql
@@ -149,7 +149,13 @@ insert into bmscantest select r, 'fooooooooooooooooooooooooooooooooooooooooooooo
 create index i_bmtest ON bmscantest(a);
 select count(*) from bmscantest where a>1;
 
+-- test accumulation of stats for parallel node
 reset enable_seqscan;
+alter table tenk2 set (parallel_workers = 0);
+explain (analyze, timing off, summary off, costs off)
+	select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0; 
+alter table tenk2 reset (parallel_workers);
+
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index 53c5254..8c53774 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -799,6 +799,19 @@ ExecParallelReinitialize(PlanState *planstate,
 	/* Old workers must already be shut down */
 	Assert(pei->finished);
 
+	/* Clear the instrumentation space from the last round. */
+	if (pei->instrumentation)
+	{
+		Instrumentation *instrument;
+		SharedExecutorInstrumentation *sh_instr;
+		int			i;
+
+		sh_instr = pei->instrumentation;
+		instrument = GetInstrumentationArray(sh_instr);
+		for (i = 0; i < sh_instr->num_workers * sh_instr->num_plan_nodes; ++i)
+			InstrInit(&instrument[i], pei->planstate->state->es_instrument);
+	}
+
 	/* Force parameters we're going to pass to workers to be evaluated. */
 	ExecEvalParamExecParams(sendParams, estate);
 
@@ -919,14 +932,25 @@ ExecParallelRetrieveInstrumentation(PlanState *planstate,
 	 * regular instrumentation information, which is the per-query context.
 	 * Switch into per-query memory context.
 	 */
-	oldcontext = MemoryContextSwitchTo(planstate->state->es_query_cxt);
-	ibytes = mul_size(instrumentation->num_workers, sizeof(Instrumentation));
-	planstate->worker_instrument =
-		palloc(ibytes + offsetof(WorkerInstrumentation, instrument));
-	MemoryContextSwitchTo(oldcontext);
+	if (!planstate->worker_instrument)
+	{
+		oldcontext = MemoryContextSwitchTo(planstate->state->es_query_cxt);
+		ibytes = mul_size(instrumentation->num_workers, sizeof(Instrumentation));
+		planstate->worker_instrument =
+			palloc(ibytes + offsetof(WorkerInstrumentation, instrument));
+		MemoryContextSwitchTo(oldcontext);
+
+		for (n = 0; n < instrumentation->num_workers; ++n)
+			InstrInit(&planstate->worker_instrument->instrument[n],
+					  planstate->state->es_instrument);
+	}
 
 	planstate->worker_instrument->num_workers = instrumentation->num_workers;
-	memcpy(&planstate->worker_instrument->instrument, instrument, ibytes);
+
+	/* Accumulate the per-worker detail. */
+	for (n = 0; n < instrumentation->num_workers; ++n)
+		InstrAggNode(&planstate->worker_instrument->instrument[n],
+					 &instrument[n]);
 
 	/*
 	 * Perform any node-type-specific work that needs to be done.  Currently,
diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out
index d1d5b22..3bb4381 100644
--- a/src/test/regress/expected/select_parallel.out
+++ b/src/test/regress/expected/select_parallel.out
@@ -378,7 +378,27 @@ select count(*) from bmscantest where a>1;
  99999
 (1 row)
 
+-- test accumulation of stats for parallel node
 reset enable_seqscan;
+alter table tenk2 set (parallel_workers = 0);
+explain (analyze, timing off, summary off, costs off)
+	select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0;
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
+ Aggregate (actual rows=1 loops=1)
+   ->  Nested Loop (actual rows=98000 loops=1)
+         ->  Seq Scan on tenk2 (actual rows=10 loops=1)
+               Filter: (thousand = 0)
+               Rows Removed by Filter: 9990
+         ->  Gather (actual rows=9800 loops=10)
+               Workers Planned: 4
+               Workers Launched: 4
+               ->  Parallel Seq Scan on tenk1 (actual rows=1960 loops=50)
+                     Filter: (hundred > 1)
+                     Rows Removed by Filter: 40
+(11 rows)
+
+alter table tenk2 reset (parallel_workers);
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;
diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql
index bb4e34a..0f006f9 100644
--- a/src/test/regress/sql/select_parallel.sql
+++ b/src/test/regress/sql/select_parallel.sql
@@ -149,7 +149,13 @@ insert into bmscantest select r, 'fooooooooooooooooooooooooooooooooooooooooooooo
 create index i_bmtest ON bmscantest(a);
 select count(*) from bmscantest where a>1;
 
+-- test accumulation of stats for parallel node
 reset enable_seqscan;
+alter table tenk2 set (parallel_workers = 0);
+explain (analyze, timing off, summary off, costs off)
+	select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0;
+alter table tenk2 reset (parallel_workers);
+
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index 53c5254..a60dd6f 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -872,11 +872,6 @@ ExecParallelReInitializeDSM(PlanState *planstate,
 				ExecBitmapHeapReInitializeDSM((BitmapHeapScanState *) planstate,
 											  pcxt);
 			break;
-		case T_SortState:
-			/* even when not parallel-aware */
-			ExecSortReInitializeDSM((SortState *) planstate, pcxt);
-			break;
-
 		default:
 			break;
 	}
@@ -987,11 +982,6 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 	for (i = 0; i < nworkers; i++)
 		InstrAccumParallelQuery(&pei->buffer_usage[i]);
 
-	/* Finally, accumulate instrumentation, if any. */
-	if (pei->instrumentation)
-		ExecParallelRetrieveInstrumentation(pei->planstate,
-											pei->instrumentation);
-
 	pei->finished = true;
 }
 
@@ -1004,6 +994,10 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 void
 ExecParallelCleanup(ParallelExecutorInfo *pei)
 {
+	/* Accumulate instrumentation, if any. */
+	if (pei->instrumentation)
+		ExecParallelRetrieveInstrumentation(pei->planstate,
+											pei->instrumentation);
 	/* Free any serialized parameters. */
 	if (DsaPointerIsValid(pei->param_exec))
 	{
diff --git a/src/backend/executor/nodeSort.c b/src/backend/executor/nodeSort.c
index 73aa371..d593378 100644
--- a/src/backend/executor/nodeSort.c
+++ b/src/backend/executor/nodeSort.c
@@ -397,23 +397,6 @@ ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt)
 }
 
 /* ----------------------------------------------------------------
- *		ExecSortReInitializeDSM
- *
- *		Reset shared state before beginning a fresh scan.
- * ----------------------------------------------------------------
- */
-void
-ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt)
-{
-	/* If there's any instrumentation space, clear it for next time */
-	if (node->shared_info != NULL)
-	{
-		memset(node->shared_info->sinstrument, 0,
-			   node->shared_info->num_workers * sizeof(TuplesortInstrumentation));
-	}
-}
-
-/* ----------------------------------------------------------------
  *		ExecSortInitializeWorker
  *
  *		Attach worker to DSM space for sort statistics.
diff --git a/src/include/executor/nodeSort.h b/src/include/executor/nodeSort.h
index cc61a9d..627a04c 100644
--- a/src/include/executor/nodeSort.h
+++ b/src/include/executor/nodeSort.h
@@ -26,7 +26,6 @@ extern void ExecReScanSort(SortState *node);
 /* parallel instrumentation support */
 extern void ExecSortEstimate(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt);
-extern void ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeWorker(SortState *node, ParallelWorkerContext *pwcxt);
 extern void ExecSortRetrieveInstrumentation(SortState *node);
 

From efe7d48a2944660a90975936d12596e6d7dbbc58 Mon Sep 17 00:00:00 2001
From: Thomas Munro <thomas.munro@enterprisedb.com>
Date: Wed, 6 Dec 2017 09:59:48 +1300
Subject: [PATCH] Add a regression test for parallel hash join rescans.

*FOR DEMONSTRATION ONLY, NOT FOR COMMIT YET*
---
 src/test/regress/expected/join.out | 106 +++++++++++++++++++++++++++++++++++++
 src/test/regress/sql/join.sql      |  60 +++++++++++++++++++++
 2 files changed, 166 insertions(+)

diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index 001d96dc2d8..9d3abf0ed05 100644
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -6187,6 +6187,112 @@ $$);
         1 |     1
 (1 row)
 
+rollback to settings;
+-- Exercise rescans.  We'll turn off parallel_leader_participation so
+-- that we can check that instrumentation comes back correctly.
+create table foo as select generate_series(1, 3) as id, 'xxxxx'::text as t;
+alter table foo set (parallel_workers = 0);
+create table bar as select generate_series(1, 5000) as id, 'xxxxx'::text as t;
+alter table bar set (parallel_workers = 2);
+-- multi-batch with rescan, parallel-oblivious
+savepoint settings;
+set parallel_leader_participation = off;
+set min_parallel_table_scan_size = 0;
+set parallel_setup_cost = 0;
+set parallel_tuple_cost = 0;
+set max_parallel_workers_per_gather = 2;
+set enable_material = off;
+set enable_mergejoin = off;
+set work_mem = '64kB';
+explain (costs off)
+  select count(*) from foo
+    left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+    on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
+ Aggregate
+   ->  Nested Loop Left Join
+         Join Filter: ((foo.id < (b1.id + 1)) AND (foo.id > (b1.id - 1)))
+         ->  Seq Scan on foo
+         ->  Gather
+               Workers Planned: 2
+               ->  Hash Join
+                     Hash Cond: (b1.id = b2.id)
+                     ->  Parallel Seq Scan on bar b1
+                     ->  Hash
+                           ->  Seq Scan on bar b2
+(11 rows)
+
+select count(*) from foo
+  left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+  on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+ count 
+-------
+     3
+(1 row)
+
+select final > 1 as multibatch
+  from hash_join_batches(
+$$
+  select count(*) from foo
+    left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+    on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+$$);
+ multibatch 
+------------
+ t
+(1 row)
+
+rollback to settings;
+-- single-batch with rescan, parallel-oblivious
+savepoint settings;
+set parallel_leader_participation = off;
+set min_parallel_table_scan_size = 0;
+set parallel_setup_cost = 0;
+set parallel_tuple_cost = 0;
+set max_parallel_workers_per_gather = 2;
+set enable_material = off;
+set enable_mergejoin = off;
+set work_mem = '4MB';
+explain (costs off)
+  select count(*) from foo
+    left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+    on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
+ Aggregate
+   ->  Nested Loop Left Join
+         Join Filter: ((foo.id < (b1.id + 1)) AND (foo.id > (b1.id - 1)))
+         ->  Seq Scan on foo
+         ->  Gather
+               Workers Planned: 2
+               ->  Hash Join
+                     Hash Cond: (b1.id = b2.id)
+                     ->  Parallel Seq Scan on bar b1
+                     ->  Hash
+                           ->  Seq Scan on bar b2
+(11 rows)
+
+select count(*) from foo
+  left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+  on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+ count 
+-------
+     3
+(1 row)
+
+select final > 1 as multibatch
+  from hash_join_batches(
+$$
+  select count(*) from foo
+    left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+    on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+$$);
+ multibatch 
+------------
+ f
+(1 row)
+
 rollback to settings;
 -- A full outer join where every record is matched.
 -- non-parallel
diff --git a/src/test/regress/sql/join.sql b/src/test/regress/sql/join.sql
index 882601b3388..0e933e00d54 100644
--- a/src/test/regress/sql/join.sql
+++ b/src/test/regress/sql/join.sql
@@ -2170,6 +2170,66 @@ $$
 $$);
 rollback to settings;
 
+-- Exercise rescans.  We'll turn off parallel_leader_participation so
+-- that we can check that instrumentation comes back correctly.
+
+create table foo as select generate_series(1, 3) as id, 'xxxxx'::text as t;
+alter table foo set (parallel_workers = 0);
+create table bar as select generate_series(1, 5000) as id, 'xxxxx'::text as t;
+alter table bar set (parallel_workers = 2);
+
+-- multi-batch with rescan, parallel-oblivious
+savepoint settings;
+set parallel_leader_participation = off;
+set min_parallel_table_scan_size = 0;
+set parallel_setup_cost = 0;
+set parallel_tuple_cost = 0;
+set max_parallel_workers_per_gather = 2;
+set enable_material = off;
+set enable_mergejoin = off;
+set work_mem = '64kB';
+explain (costs off)
+  select count(*) from foo
+    left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+    on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+select count(*) from foo
+  left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+  on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+select final > 1 as multibatch
+  from hash_join_batches(
+$$
+  select count(*) from foo
+    left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+    on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+$$);
+rollback to settings;
+
+-- single-batch with rescan, parallel-oblivious
+savepoint settings;
+set parallel_leader_participation = off;
+set min_parallel_table_scan_size = 0;
+set parallel_setup_cost = 0;
+set parallel_tuple_cost = 0;
+set max_parallel_workers_per_gather = 2;
+set enable_material = off;
+set enable_mergejoin = off;
+set work_mem = '4MB';
+explain (costs off)
+  select count(*) from foo
+    left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+    on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+select count(*) from foo
+  left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+  on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+select final > 1 as multibatch
+  from hash_join_batches(
+$$
+  select count(*) from foo
+    left join (select b1.id, b1.t from bar b1 join bar b2 using (id)) ss
+    on foo.id < ss.id + 1 and foo.id > ss.id - 1;
+$$);
+rollback to settings;
+
 -- A full outer join where every record is matched.
 
 -- non-parallel
-- 
2.15.0

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index 558cb08..da43896 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -819,19 +819,6 @@ ExecParallelReinitialize(PlanState *planstate,
 	/* Old workers must already be shut down */
 	Assert(pei->finished);
 
-	/* Clear the instrumentation space from the last round. */
-	if (pei->instrumentation)
-	{
-		Instrumentation *instrument;
-		SharedExecutorInstrumentation *sh_instr;
-		int			i;
-
-		sh_instr = pei->instrumentation;
-		instrument = GetInstrumentationArray(sh_instr);
-		for (i = 0; i < sh_instr->num_workers * sh_instr->num_plan_nodes; ++i)
-			InstrInit(&instrument[i], pei->planstate->state->es_instrument);
-	}
-
 	/* Force parameters we're going to pass to workers to be evaluated. */
 	ExecEvalParamExecParams(sendParams, estate);
 
@@ -909,14 +896,6 @@ ExecParallelReInitializeDSM(PlanState *planstate,
 				ExecBitmapHeapReInitializeDSM((BitmapHeapScanState *) planstate,
 											  pcxt);
 			break;
-		case T_HashState:
-			/* even when not parallel-aware, for EXPLAIN ANALYZE */
-			ExecHashReInitializeDSM((HashState *) planstate, pcxt);
-			break;
-		case T_SortState:
-			/* even when not parallel-aware, for EXPLAIN ANALYZE */
-			ExecSortReInitializeDSM((SortState *) planstate, pcxt);
-			break;
 
 		default:
 			break;
@@ -1046,11 +1025,6 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 	for (i = 0; i < nworkers; i++)
 		InstrAccumParallelQuery(&pei->buffer_usage[i]);
 
-	/* Finally, accumulate instrumentation, if any. */
-	if (pei->instrumentation)
-		ExecParallelRetrieveInstrumentation(pei->planstate,
-											pei->instrumentation);
-
 	pei->finished = true;
 }
 
@@ -1063,6 +1037,11 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 void
 ExecParallelCleanup(ParallelExecutorInfo *pei)
 {
+	/* Accumulate instrumentation, if any. */
+	if (pei->instrumentation)
+		ExecParallelRetrieveInstrumentation(pei->planstate,
+											pei->instrumentation);
+
 	/* Free any serialized parameters. */
 	if (DsaPointerIsValid(pei->param_exec))
 	{
diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c
index 6fe5d69..afd7384 100644
--- a/src/backend/executor/nodeHash.c
+++ b/src/backend/executor/nodeHash.c
@@ -1670,19 +1670,6 @@ ExecHashInitializeDSM(HashState *node, ParallelContext *pcxt)
 }
 
 /*
- * Reset shared state before beginning a fresh scan.
- */
-void
-ExecHashReInitializeDSM(HashState *node, ParallelContext *pcxt)
-{
-	if (node->shared_info != NULL)
-	{
-		memset(node->shared_info->hinstrument, 0,
-			   node->shared_info->num_workers * sizeof(HashInstrumentation));
-	}
-}
-
-/*
  * Locate the DSM space for hash table instrumentation data that we'll write
  * to at shutdown time.
  */
diff --git a/src/backend/executor/nodeSort.c b/src/backend/executor/nodeSort.c
index 73aa371..d593378 100644
--- a/src/backend/executor/nodeSort.c
+++ b/src/backend/executor/nodeSort.c
@@ -397,23 +397,6 @@ ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt)
 }
 
 /* ----------------------------------------------------------------
- *		ExecSortReInitializeDSM
- *
- *		Reset shared state before beginning a fresh scan.
- * ----------------------------------------------------------------
- */
-void
-ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt)
-{
-	/* If there's any instrumentation space, clear it for next time */
-	if (node->shared_info != NULL)
-	{
-		memset(node->shared_info->sinstrument, 0,
-			   node->shared_info->num_workers * sizeof(TuplesortInstrumentation));
-	}
-}
-
-/* ----------------------------------------------------------------
  *		ExecSortInitializeWorker
  *
  *		Attach worker to DSM space for sort statistics.
diff --git a/src/include/executor/nodeHash.h b/src/include/executor/nodeHash.h
index 75d4c70..0974f1e 100644
--- a/src/include/executor/nodeHash.h
+++ b/src/include/executor/nodeHash.h
@@ -52,7 +52,6 @@ extern int	ExecHashGetSkewBucket(HashJoinTable hashtable, uint32 hashvalue);
 extern void ExecHashEstimate(HashState *node, ParallelContext *pcxt);
 extern void ExecHashInitializeDSM(HashState *node, ParallelContext *pcxt);
 extern void ExecHashInitializeWorker(HashState *node, ParallelWorkerContext *pwcxt);
-extern void ExecHashReInitializeDSM(HashState *node, ParallelContext *pcxt);
 extern void ExecHashRetrieveInstrumentation(HashState *node);
 extern void ExecShutdownHash(HashState *node);
 extern void ExecHashGetInstrumentation(HashInstrumentation *instrument,
diff --git a/src/include/executor/nodeSort.h b/src/include/executor/nodeSort.h
index cc61a9d..627a04c 100644
--- a/src/include/executor/nodeSort.h
+++ b/src/include/executor/nodeSort.h
@@ -26,7 +26,6 @@ extern void ExecReScanSort(SortState *node);
 /* parallel instrumentation support */
 extern void ExecSortEstimate(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt);
-extern void ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeWorker(SortState *node, ParallelWorkerContext *pwcxt);
 extern void ExecSortRetrieveInstrumentation(SortState *node);
 

diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out
index ff00d47..de0d0b4 100644
--- a/src/test/regress/expected/select_parallel.out
+++ b/src/test/regress/expected/select_parallel.out
@@ -486,6 +486,28 @@ explain (analyze, timing off, summary off, costs off)
                      Rows Removed by Filter: 40
 (11 rows)
 
+explain (analyze, timing off, summary off, costs off)
+  select * from
+  (select ten from tenk1 where ten < 100 order by ten) ss
+  right join (values (1),(2),(3)) v(x) on true;
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
+ Nested Loop Left Join (actual rows=30000 loops=1)
+   ->  Values Scan on "*VALUES*" (actual rows=3 loops=1)
+   ->  Gather Merge (actual rows=10000 loops=3)
+         Workers Planned: 4
+         Workers Launched: 4
+         ->  Sort (actual rows=2000 loops=15)
+               Sort Key: tenk1.ten
+               Sort Method: external sort  Disk: 200kB
+               Worker 0:  Sort Method: quicksort  Memory: 25kB
+               Worker 1:  Sort Method: quicksort  Memory: 25kB
+               Worker 2:  Sort Method: quicksort  Memory: 25kB
+               Worker 3:  Sort Method: quicksort  Memory: 25kB
+               ->  Parallel Seq Scan on tenk1 (actual rows=2000 loops=15)
+                     Filter: (ten < 100)
+(14 rows)
+
 alter table tenk2 reset (parallel_workers);
 reset enable_indexscan;
 reset enable_hashjoin;
diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql
index 1035d04..f066dd5 100644
--- a/src/test/regress/sql/select_parallel.sql
+++ b/src/test/regress/sql/select_parallel.sql
@@ -185,6 +185,10 @@ alter table tenk2 set (parallel_workers = 0);
 explain (analyze, timing off, summary off, costs off)
 	select count(*) from tenk1, tenk2 where tenk1.hundred > 1
         and tenk2.thousand=0;
+explain (analyze, timing off, summary off, costs off)
+  select * from
+  (select ten from tenk1 where ten < 100 order by ten) ss
+  right join (values (1),(2),(3)) v(x) on true;
 alter table tenk2 reset (parallel_workers);
 
 reset enable_indexscan;

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index 558cb08..64ca8d8 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -819,19 +819,6 @@ ExecParallelReinitialize(PlanState *planstate,
 	/* Old workers must already be shut down */
 	Assert(pei->finished);
 
-	/* Clear the instrumentation space from the last round. */
-	if (pei->instrumentation)
-	{
-		Instrumentation *instrument;
-		SharedExecutorInstrumentation *sh_instr;
-		int			i;
-
-		sh_instr = pei->instrumentation;
-		instrument = GetInstrumentationArray(sh_instr);
-		for (i = 0; i < sh_instr->num_workers * sh_instr->num_plan_nodes; ++i)
-			InstrInit(&instrument[i], pei->planstate->state->es_instrument);
-	}
-
 	/* Force parameters we're going to pass to workers to be evaluated. */
 	ExecEvalParamExecParams(sendParams, estate);
 
@@ -910,12 +897,8 @@ ExecParallelReInitializeDSM(PlanState *planstate,
 											  pcxt);
 			break;
 		case T_HashState:
-			/* even when not parallel-aware, for EXPLAIN ANALYZE */
-			ExecHashReInitializeDSM((HashState *) planstate, pcxt);
-			break;
 		case T_SortState:
-			/* even when not parallel-aware, for EXPLAIN ANALYZE */
-			ExecSortReInitializeDSM((SortState *) planstate, pcxt);
+			/* these nodes have DSM state, but no reinitialization is required */
 			break;
 
 		default:
@@ -1046,11 +1029,6 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 	for (i = 0; i < nworkers; i++)
 		InstrAccumParallelQuery(&pei->buffer_usage[i]);
 
-	/* Finally, accumulate instrumentation, if any. */
-	if (pei->instrumentation)
-		ExecParallelRetrieveInstrumentation(pei->planstate,
-											pei->instrumentation);
-
 	pei->finished = true;
 }
 
@@ -1063,6 +1041,11 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 void
 ExecParallelCleanup(ParallelExecutorInfo *pei)
 {
+	/* Accumulate instrumentation, if any. */
+	if (pei->instrumentation)
+		ExecParallelRetrieveInstrumentation(pei->planstate,
+											pei->instrumentation);
+
 	/* Free any serialized parameters. */
 	if (DsaPointerIsValid(pei->param_exec))
 	{
diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c
index 6fe5d69..afd7384 100644
--- a/src/backend/executor/nodeHash.c
+++ b/src/backend/executor/nodeHash.c
@@ -1670,19 +1670,6 @@ ExecHashInitializeDSM(HashState *node, ParallelContext *pcxt)
 }
 
 /*
- * Reset shared state before beginning a fresh scan.
- */
-void
-ExecHashReInitializeDSM(HashState *node, ParallelContext *pcxt)
-{
-	if (node->shared_info != NULL)
-	{
-		memset(node->shared_info->hinstrument, 0,
-			   node->shared_info->num_workers * sizeof(HashInstrumentation));
-	}
-}
-
-/*
  * Locate the DSM space for hash table instrumentation data that we'll write
  * to at shutdown time.
  */
diff --git a/src/backend/executor/nodeSort.c b/src/backend/executor/nodeSort.c
index 73aa371..d593378 100644
--- a/src/backend/executor/nodeSort.c
+++ b/src/backend/executor/nodeSort.c
@@ -397,23 +397,6 @@ ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt)
 }
 
 /* ----------------------------------------------------------------
- *		ExecSortReInitializeDSM
- *
- *		Reset shared state before beginning a fresh scan.
- * ----------------------------------------------------------------
- */
-void
-ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt)
-{
-	/* If there's any instrumentation space, clear it for next time */
-	if (node->shared_info != NULL)
-	{
-		memset(node->shared_info->sinstrument, 0,
-			   node->shared_info->num_workers * sizeof(TuplesortInstrumentation));
-	}
-}
-
-/* ----------------------------------------------------------------
  *		ExecSortInitializeWorker
  *
  *		Attach worker to DSM space for sort statistics.
diff --git a/src/include/executor/nodeHash.h b/src/include/executor/nodeHash.h
index 75d4c70..0974f1e 100644
--- a/src/include/executor/nodeHash.h
+++ b/src/include/executor/nodeHash.h
@@ -52,7 +52,6 @@ extern int	ExecHashGetSkewBucket(HashJoinTable hashtable, uint32 hashvalue);
 extern void ExecHashEstimate(HashState *node, ParallelContext *pcxt);
 extern void ExecHashInitializeDSM(HashState *node, ParallelContext *pcxt);
 extern void ExecHashInitializeWorker(HashState *node, ParallelWorkerContext *pwcxt);
-extern void ExecHashReInitializeDSM(HashState *node, ParallelContext *pcxt);
 extern void ExecHashRetrieveInstrumentation(HashState *node);
 extern void ExecShutdownHash(HashState *node);
 extern void ExecHashGetInstrumentation(HashInstrumentation *instrument,
diff --git a/src/include/executor/nodeSort.h b/src/include/executor/nodeSort.h
index cc61a9d..627a04c 100644
--- a/src/include/executor/nodeSort.h
+++ b/src/include/executor/nodeSort.h
@@ -26,7 +26,6 @@ extern void ExecReScanSort(SortState *node);
 /* parallel instrumentation support */
 extern void ExecSortEstimate(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt);
-extern void ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeWorker(SortState *node, ParallelWorkerContext *pwcxt);
 extern void ExecSortRetrieveInstrumentation(SortState *node);
 
diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out
index ff00d47..5323d67 100644
--- a/src/test/regress/expected/select_parallel.out
+++ b/src/test/regress/expected/select_parallel.out
@@ -487,12 +487,47 @@ explain (analyze, timing off, summary off, costs off)
 (11 rows)
 
 alter table tenk2 reset (parallel_workers);
+reset work_mem;
+create function explain_parallel_sort_stats() returns setof text
+language plpgsql as
+$$
+declare ln text;
+begin
+    for ln in
+        explain (analyze, timing off, summary off, costs off)
+          select * from
+          (select ten from tenk1 where ten < 100 order by ten) ss
+          right join (values (1),(2),(3)) v(x) on true
+    loop
+        ln := regexp_replace(ln, 'Memory: \S*',  'Memory: xxx');
+        return next ln;
+    end loop;
+end;
+$$;
+select * from explain_parallel_sort_stats();
+                       explain_parallel_sort_stats                        
+--------------------------------------------------------------------------
+ Nested Loop Left Join (actual rows=30000 loops=1)
+   ->  Values Scan on "*VALUES*" (actual rows=3 loops=1)
+   ->  Gather Merge (actual rows=10000 loops=3)
+         Workers Planned: 4
+         Workers Launched: 4
+         ->  Sort (actual rows=2000 loops=15)
+               Sort Key: tenk1.ten
+               Sort Method: quicksort  Memory: xxx
+               Worker 0:  Sort Method: quicksort  Memory: xxx
+               Worker 1:  Sort Method: quicksort  Memory: xxx
+               Worker 2:  Sort Method: quicksort  Memory: xxx
+               Worker 3:  Sort Method: quicksort  Memory: xxx
+               ->  Parallel Seq Scan on tenk1 (actual rows=2000 loops=15)
+                     Filter: (ten < 100)
+(14 rows)
+
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;
 reset enable_material;
 reset effective_io_concurrency;
-reset work_mem;
 drop table bmscantest;
 -- test parallel merge join path.
 set enable_hashjoin to off;
diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql
index 1035d04..c1b2d9a 100644
--- a/src/test/regress/sql/select_parallel.sql
+++ b/src/test/regress/sql/select_parallel.sql
@@ -187,12 +187,30 @@ explain (analyze, timing off, summary off, costs off)
         and tenk2.thousand=0;
 alter table tenk2 reset (parallel_workers);
 
+reset work_mem;
+create function explain_parallel_sort_stats() returns setof text
+language plpgsql as
+$$
+declare ln text;
+begin
+    for ln in
+        explain (analyze, timing off, summary off, costs off)
+          select * from
+          (select ten from tenk1 where ten < 100 order by ten) ss
+          right join (values (1),(2),(3)) v(x) on true
+    loop
+        ln := regexp_replace(ln, 'Memory: \S*',  'Memory: xxx');
+        return next ln;
+    end loop;
+end;
+$$;
+select * from explain_parallel_sort_stats();
+
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;
 reset enable_material;
 reset effective_io_concurrency;
-reset work_mem;
 drop table bmscantest;
 
 -- test parallel merge join path.

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index 558cb08..64ca8d8 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -819,19 +819,6 @@ ExecParallelReinitialize(PlanState *planstate,
 	/* Old workers must already be shut down */
 	Assert(pei->finished);
 
-	/* Clear the instrumentation space from the last round. */
-	if (pei->instrumentation)
-	{
-		Instrumentation *instrument;
-		SharedExecutorInstrumentation *sh_instr;
-		int			i;
-
-		sh_instr = pei->instrumentation;
-		instrument = GetInstrumentationArray(sh_instr);
-		for (i = 0; i < sh_instr->num_workers * sh_instr->num_plan_nodes; ++i)
-			InstrInit(&instrument[i], pei->planstate->state->es_instrument);
-	}
-
 	/* Force parameters we're going to pass to workers to be evaluated. */
 	ExecEvalParamExecParams(sendParams, estate);
 
@@ -910,12 +897,8 @@ ExecParallelReInitializeDSM(PlanState *planstate,
 											  pcxt);
 			break;
 		case T_HashState:
-			/* even when not parallel-aware, for EXPLAIN ANALYZE */
-			ExecHashReInitializeDSM((HashState *) planstate, pcxt);
-			break;
 		case T_SortState:
-			/* even when not parallel-aware, for EXPLAIN ANALYZE */
-			ExecSortReInitializeDSM((SortState *) planstate, pcxt);
+			/* these nodes have DSM state, but no reinitialization is required */
 			break;
 
 		default:
@@ -1046,11 +1029,6 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 	for (i = 0; i < nworkers; i++)
 		InstrAccumParallelQuery(&pei->buffer_usage[i]);
 
-	/* Finally, accumulate instrumentation, if any. */
-	if (pei->instrumentation)
-		ExecParallelRetrieveInstrumentation(pei->planstate,
-											pei->instrumentation);
-
 	pei->finished = true;
 }
 
@@ -1063,6 +1041,11 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 void
 ExecParallelCleanup(ParallelExecutorInfo *pei)
 {
+	/* Accumulate instrumentation, if any. */
+	if (pei->instrumentation)
+		ExecParallelRetrieveInstrumentation(pei->planstate,
+											pei->instrumentation);
+
 	/* Free any serialized parameters. */
 	if (DsaPointerIsValid(pei->param_exec))
 	{
diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c
index 6fe5d69..afd7384 100644
--- a/src/backend/executor/nodeHash.c
+++ b/src/backend/executor/nodeHash.c
@@ -1670,19 +1670,6 @@ ExecHashInitializeDSM(HashState *node, ParallelContext *pcxt)
 }
 
 /*
- * Reset shared state before beginning a fresh scan.
- */
-void
-ExecHashReInitializeDSM(HashState *node, ParallelContext *pcxt)
-{
-	if (node->shared_info != NULL)
-	{
-		memset(node->shared_info->hinstrument, 0,
-			   node->shared_info->num_workers * sizeof(HashInstrumentation));
-	}
-}
-
-/*
  * Locate the DSM space for hash table instrumentation data that we'll write
  * to at shutdown time.
  */
diff --git a/src/backend/executor/nodeSort.c b/src/backend/executor/nodeSort.c
index 73aa371..d593378 100644
--- a/src/backend/executor/nodeSort.c
+++ b/src/backend/executor/nodeSort.c
@@ -397,23 +397,6 @@ ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt)
 }
 
 /* ----------------------------------------------------------------
- *		ExecSortReInitializeDSM
- *
- *		Reset shared state before beginning a fresh scan.
- * ----------------------------------------------------------------
- */
-void
-ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt)
-{
-	/* If there's any instrumentation space, clear it for next time */
-	if (node->shared_info != NULL)
-	{
-		memset(node->shared_info->sinstrument, 0,
-			   node->shared_info->num_workers * sizeof(TuplesortInstrumentation));
-	}
-}
-
-/* ----------------------------------------------------------------
  *		ExecSortInitializeWorker
  *
  *		Attach worker to DSM space for sort statistics.
diff --git a/src/include/executor/nodeHash.h b/src/include/executor/nodeHash.h
index 75d4c70..0974f1e 100644
--- a/src/include/executor/nodeHash.h
+++ b/src/include/executor/nodeHash.h
@@ -52,7 +52,6 @@ extern int	ExecHashGetSkewBucket(HashJoinTable hashtable, uint32 hashvalue);
 extern void ExecHashEstimate(HashState *node, ParallelContext *pcxt);
 extern void ExecHashInitializeDSM(HashState *node, ParallelContext *pcxt);
 extern void ExecHashInitializeWorker(HashState *node, ParallelWorkerContext *pwcxt);
-extern void ExecHashReInitializeDSM(HashState *node, ParallelContext *pcxt);
 extern void ExecHashRetrieveInstrumentation(HashState *node);
 extern void ExecShutdownHash(HashState *node);
 extern void ExecHashGetInstrumentation(HashInstrumentation *instrument,
diff --git a/src/include/executor/nodeSort.h b/src/include/executor/nodeSort.h
index cc61a9d..627a04c 100644
--- a/src/include/executor/nodeSort.h
+++ b/src/include/executor/nodeSort.h
@@ -26,7 +26,6 @@ extern void ExecReScanSort(SortState *node);
 /* parallel instrumentation support */
 extern void ExecSortEstimate(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt);
-extern void ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeWorker(SortState *node, ParallelWorkerContext *pwcxt);
 extern void ExecSortRetrieveInstrumentation(SortState *node);
 
diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out
index ff00d47..dde10b5 100644
--- a/src/test/regress/expected/select_parallel.out
+++ b/src/test/regress/expected/select_parallel.out
@@ -487,13 +487,49 @@ explain (analyze, timing off, summary off, costs off)
 (11 rows)
 
 alter table tenk2 reset (parallel_workers);
+reset work_mem;
+create function explain_parallel_sort_stats() returns setof text
+language plpgsql as
+$$
+declare ln text;
+begin
+    for ln in
+        explain (analyze, timing off, summary off, costs off)
+          select * from
+          (select ten from tenk1 where ten < 100 order by ten) ss
+          right join (values (1),(2),(3)) v(x) on true
+    loop
+        ln := regexp_replace(ln, 'Memory: \S*',  'Memory: xxx');
+        return next ln;
+    end loop;
+end;
+$$;
+select * from explain_parallel_sort_stats();
+                       explain_parallel_sort_stats                        
+--------------------------------------------------------------------------
+ Nested Loop Left Join (actual rows=30000 loops=1)
+   ->  Values Scan on "*VALUES*" (actual rows=3 loops=1)
+   ->  Gather Merge (actual rows=10000 loops=3)
+         Workers Planned: 4
+         Workers Launched: 4
+         ->  Sort (actual rows=2000 loops=15)
+               Sort Key: tenk1.ten
+               Sort Method: quicksort  Memory: xxx
+               Worker 0:  Sort Method: quicksort  Memory: xxx
+               Worker 1:  Sort Method: quicksort  Memory: xxx
+               Worker 2:  Sort Method: quicksort  Memory: xxx
+               Worker 3:  Sort Method: quicksort  Memory: xxx
+               ->  Parallel Seq Scan on tenk1 (actual rows=2000 loops=15)
+                     Filter: (ten < 100)
+(14 rows)
+
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;
 reset enable_material;
 reset effective_io_concurrency;
-reset work_mem;
 drop table bmscantest;
+drop function explain_parallel_sort_stats();
 -- test parallel merge join path.
 set enable_hashjoin to off;
 set enable_nestloop to off;
diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql
index 1035d04..944782c 100644
--- a/src/test/regress/sql/select_parallel.sql
+++ b/src/test/regress/sql/select_parallel.sql
@@ -187,13 +187,32 @@ explain (analyze, timing off, summary off, costs off)
         and tenk2.thousand=0;
 alter table tenk2 reset (parallel_workers);
 
+reset work_mem;
+create function explain_parallel_sort_stats() returns setof text
+language plpgsql as
+$$
+declare ln text;
+begin
+    for ln in
+        explain (analyze, timing off, summary off, costs off)
+          select * from
+          (select ten from tenk1 where ten < 100 order by ten) ss
+          right join (values (1),(2),(3)) v(x) on true
+    loop
+        ln := regexp_replace(ln, 'Memory: \S*',  'Memory: xxx');
+        return next ln;
+    end loop;
+end;
+$$;
+select * from explain_parallel_sort_stats();
+
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;
 reset enable_material;
 reset effective_io_concurrency;
-reset work_mem;
 drop table bmscantest;
+drop function explain_parallel_sort_stats();
 
 -- test parallel merge join path.
 set enable_hashjoin to off;

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index d57cdbd..89d87d5 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -897,12 +897,8 @@ ExecParallelReInitializeDSM(PlanState *planstate,
 											  pcxt);
 			break;
 		case T_HashState:
-			/* even when not parallel-aware, for EXPLAIN ANALYZE */
-			ExecHashReInitializeDSM((HashState *) planstate, pcxt);
-			break;
 		case T_SortState:
-			/* even when not parallel-aware, for EXPLAIN ANALYZE */
-			ExecSortReInitializeDSM((SortState *) planstate, pcxt);
+			/* these nodes have DSM state, but no reinitialization is required */
 			break;
 
 		default:
@@ -975,7 +971,7 @@ ExecParallelRetrieveInstrumentation(PlanState *planstate,
 
 /*
  * Finish parallel execution.  We wait for parallel workers to finish, and
- * accumulate their buffer usage and instrumentation.
+ * accumulate their buffer usage.
  */
 void
 ExecParallelFinish(ParallelExecutorInfo *pei)
@@ -1021,23 +1017,23 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 	for (i = 0; i < nworkers; i++)
 		InstrAccumParallelQuery(&pei->buffer_usage[i]);
 
-	/* Finally, accumulate instrumentation, if any. */
-	if (pei->instrumentation)
-		ExecParallelRetrieveInstrumentation(pei->planstate,
-											pei->instrumentation);
-
 	pei->finished = true;
 }
 
 /*
  * Clean up whatever ParallelExecutorInfo resources still exist after
- * ExecParallelFinish.  We separate these routines because someone might
- * want to examine the contents of the DSM after ExecParallelFinish and
- * before calling this routine.
+ * ExecParallelFinish and accumulate instrumentation.  We separate these
+ * routines because someone might want to examine the contents of the DSM
+ * after ExecParallelFinish and before calling this routine.
  */
 void
 ExecParallelCleanup(ParallelExecutorInfo *pei)
 {
+	/* Accumulate instrumentation, if any. */
+	if (pei->instrumentation)
+		ExecParallelRetrieveInstrumentation(pei->planstate,
+											pei->instrumentation);
+
 	/* Free any serialized parameters. */
 	if (DsaPointerIsValid(pei->param_exec))
 	{
diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c
index 6fe5d69..afd7384 100644
--- a/src/backend/executor/nodeHash.c
+++ b/src/backend/executor/nodeHash.c
@@ -1670,19 +1670,6 @@ ExecHashInitializeDSM(HashState *node, ParallelContext *pcxt)
 }
 
 /*
- * Reset shared state before beginning a fresh scan.
- */
-void
-ExecHashReInitializeDSM(HashState *node, ParallelContext *pcxt)
-{
-	if (node->shared_info != NULL)
-	{
-		memset(node->shared_info->hinstrument, 0,
-			   node->shared_info->num_workers * sizeof(HashInstrumentation));
-	}
-}
-
-/*
  * Locate the DSM space for hash table instrumentation data that we'll write
  * to at shutdown time.
  */
diff --git a/src/backend/executor/nodeSort.c b/src/backend/executor/nodeSort.c
index 73aa371..d593378 100644
--- a/src/backend/executor/nodeSort.c
+++ b/src/backend/executor/nodeSort.c
@@ -397,23 +397,6 @@ ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt)
 }
 
 /* ----------------------------------------------------------------
- *		ExecSortReInitializeDSM
- *
- *		Reset shared state before beginning a fresh scan.
- * ----------------------------------------------------------------
- */
-void
-ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt)
-{
-	/* If there's any instrumentation space, clear it for next time */
-	if (node->shared_info != NULL)
-	{
-		memset(node->shared_info->sinstrument, 0,
-			   node->shared_info->num_workers * sizeof(TuplesortInstrumentation));
-	}
-}
-
-/* ----------------------------------------------------------------
  *		ExecSortInitializeWorker
  *
  *		Attach worker to DSM space for sort statistics.
diff --git a/src/include/executor/nodeHash.h b/src/include/executor/nodeHash.h
index 75d4c70..0974f1e 100644
--- a/src/include/executor/nodeHash.h
+++ b/src/include/executor/nodeHash.h
@@ -52,7 +52,6 @@ extern int	ExecHashGetSkewBucket(HashJoinTable hashtable, uint32 hashvalue);
 extern void ExecHashEstimate(HashState *node, ParallelContext *pcxt);
 extern void ExecHashInitializeDSM(HashState *node, ParallelContext *pcxt);
 extern void ExecHashInitializeWorker(HashState *node, ParallelWorkerContext *pwcxt);
-extern void ExecHashReInitializeDSM(HashState *node, ParallelContext *pcxt);
 extern void ExecHashRetrieveInstrumentation(HashState *node);
 extern void ExecShutdownHash(HashState *node);
 extern void ExecHashGetInstrumentation(HashInstrumentation *instrument,
diff --git a/src/include/executor/nodeSort.h b/src/include/executor/nodeSort.h
index cc61a9d..627a04c 100644
--- a/src/include/executor/nodeSort.h
+++ b/src/include/executor/nodeSort.h
@@ -26,7 +26,6 @@ extern void ExecReScanSort(SortState *node);
 /* parallel instrumentation support */
 extern void ExecSortEstimate(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt);
-extern void ExecSortReInitializeDSM(SortState *node, ParallelContext *pcxt);
 extern void ExecSortInitializeWorker(SortState *node, ParallelWorkerContext *pwcxt);
 extern void ExecSortRetrieveInstrumentation(SortState *node);
 
diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out
index 86a5592..7824ca5 100644
--- a/src/test/regress/expected/select_parallel.out
+++ b/src/test/regress/expected/select_parallel.out
@@ -465,14 +465,71 @@ select count(*) from bmscantest where a>1;
  99999
 (1 row)
 
+-- test accumulation of stats for parallel nodes
 reset enable_seqscan;
+alter table tenk2 set (parallel_workers = 0);
+explain (analyze, timing off, summary off, costs off)
+   select count(*) from tenk1, tenk2 where tenk1.hundred > 1
+        and tenk2.thousand=0;
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
+ Aggregate (actual rows=1 loops=1)
+   ->  Nested Loop (actual rows=98000 loops=1)
+         ->  Seq Scan on tenk2 (actual rows=10 loops=1)
+               Filter: (thousand = 0)
+               Rows Removed by Filter: 9990
+         ->  Gather (actual rows=9800 loops=10)
+               Workers Planned: 4
+               Workers Launched: 4
+               ->  Parallel Seq Scan on tenk1 (actual rows=1960 loops=50)
+                     Filter: (hundred > 1)
+                     Rows Removed by Filter: 40
+(11 rows)
+
+alter table tenk2 reset (parallel_workers);
+reset work_mem;
+create function explain_parallel_sort_stats() returns setof text
+language plpgsql as
+$$
+declare ln text;
+begin
+    for ln in
+        explain (analyze, timing off, summary off, costs off)
+          select * from
+          (select ten from tenk1 where ten < 100 order by ten) ss
+          right join (values (1),(2),(3)) v(x) on true
+    loop
+        ln := regexp_replace(ln, 'Memory: \S*',  'Memory: xxx');
+        return next ln;
+    end loop;
+end;
+$$;
+select * from explain_parallel_sort_stats();
+                       explain_parallel_sort_stats                        
+--------------------------------------------------------------------------
+ Nested Loop Left Join (actual rows=30000 loops=1)
+   ->  Values Scan on "*VALUES*" (actual rows=3 loops=1)
+   ->  Gather Merge (actual rows=10000 loops=3)
+         Workers Planned: 4
+         Workers Launched: 4
+         ->  Sort (actual rows=2000 loops=15)
+               Sort Key: tenk1.ten
+               Sort Method: quicksort  Memory: xxx
+               Worker 0:  Sort Method: quicksort  Memory: xxx
+               Worker 1:  Sort Method: quicksort  Memory: xxx
+               Worker 2:  Sort Method: quicksort  Memory: xxx
+               Worker 3:  Sort Method: quicksort  Memory: xxx
+               ->  Parallel Seq Scan on tenk1 (actual rows=2000 loops=15)
+                     Filter: (ten < 100)
+(14 rows)
+
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;
 reset enable_material;
 reset effective_io_concurrency;
-reset work_mem;
 drop table bmscantest;
+drop function explain_parallel_sort_stats();
 -- test parallel merge join path.
 set enable_hashjoin to off;
 set enable_nestloop to off;
diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql
index fb35ca3..b12ba0b 100644
--- a/src/test/regress/sql/select_parallel.sql
+++ b/src/test/regress/sql/select_parallel.sql
@@ -179,14 +179,40 @@ insert into bmscantest select r, 'fooooooooooooooooooooooooooooooooooooooooooooo
 create index i_bmtest ON bmscantest(a);
 select count(*) from bmscantest where a>1;
 
+-- test accumulation of stats for parallel nodes
 reset enable_seqscan;
+alter table tenk2 set (parallel_workers = 0);
+explain (analyze, timing off, summary off, costs off)
+   select count(*) from tenk1, tenk2 where tenk1.hundred > 1
+        and tenk2.thousand=0;
+alter table tenk2 reset (parallel_workers);
+
+reset work_mem;
+create function explain_parallel_sort_stats() returns setof text
+language plpgsql as
+$$
+declare ln text;
+begin
+    for ln in
+        explain (analyze, timing off, summary off, costs off)
+          select * from
+          (select ten from tenk1 where ten < 100 order by ten) ss
+          right join (values (1),(2),(3)) v(x) on true
+    loop
+        ln := regexp_replace(ln, 'Memory: \S*',  'Memory: xxx');
+        return next ln;
+    end loop;
+end;
+$$;
+select * from explain_parallel_sort_stats();
+
 reset enable_indexscan;
 reset enable_hashjoin;
 reset enable_mergejoin;
 reset enable_material;
 reset effective_io_concurrency;
-reset work_mem;
 drop table bmscantest;
+drop function explain_parallel_sort_stats();
 
 -- test parallel merge join path.
 set enable_hashjoin to off;

diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index 4741aec..6eed6db 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -536,7 +536,7 @@ ExecParallelRetrieveInstrumentation(PlanState *planstate,
 
 /*
  * Finish parallel execution.  We wait for parallel workers to finish, and
- * accumulate their buffer usage and instrumentation.
+ * accumulate their buffer usage.
  */
 void
 ExecParallelFinish(ParallelExecutorInfo *pei)
@@ -553,23 +553,23 @@ ExecParallelFinish(ParallelExecutorInfo *pei)
 	for (i = 0; i < pei->pcxt->nworkers_launched; ++i)
 		InstrAccumParallelQuery(&pei->buffer_usage[i]);
 
-	/* Finally, accumulate instrumentation, if any. */
-	if (pei->instrumentation)
-		ExecParallelRetrieveInstrumentation(pei->planstate,
-											pei->instrumentation);
-
 	pei->finished = true;
 }
 
 /*
- * Clean up whatever ParallelExecutorInfo resources still exist after
- * ExecParallelFinish.  We separate these routines because someone might
- * want to examine the contents of the DSM after ExecParallelFinish and
- * before calling this routine.
+ * Accumulate instrumentation, and then clean up whatever ParallelExecutorInfo
+ * resources still exist after ExecParallelFinish.  We separate these
+ * routines because someone might want to examine the contents of the DSM
+ * after ExecParallelFinish and before calling this routine.
  */
 void
 ExecParallelCleanup(ParallelExecutorInfo *pei)
 {
+	/* Accumulate instrumentation, if any. */
+	if (pei->instrumentation)
+		ExecParallelRetrieveInstrumentation(pei->planstate,
+											pei->instrumentation);
+
 	if (pei->pcxt != NULL)
 	{
 		DestroyParallelContext(pei->pcxt);
diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out
index 72dd420..43801e0 100644
--- a/src/test/regress/expected/select_parallel.out
+++ b/src/test/regress/expected/select_parallel.out
@@ -123,6 +123,50 @@ select avg(aa::int8) from a_star;
  13.6538461538461538
 (1 row)
 
+-- test accumulation of stats for parallel nodes
+set enable_indexscan to off;
+set enable_bitmapscan to off;
+set enable_material to off;
+alter table tenk2 set (parallel_workers = 0);
+create function explain_parallel_stats() returns setof text
+language plpgsql as
+$$
+declare ln text;
+begin
+    for ln in
+        explain (analyze, timing off, costs off)
+          select count(*) from tenk1, tenk2 where
+            tenk1.hundred > 1 and tenk2.thousand=0
+    loop
+        ln := regexp_replace(ln, 'Planning time: \S*',  'Planning time: xxx');
+        ln := regexp_replace(ln, 'Execution time: \S*', 'Execution time: xxx');
+        return next ln;
+    end loop;
+end;
+$$;
+select * from explain_parallel_stats();
+                          explain_parallel_stats                          
+--------------------------------------------------------------------------
+ Aggregate (actual rows=1 loops=1)
+   ->  Nested Loop (actual rows=98000 loops=1)
+         ->  Seq Scan on tenk2 (actual rows=10 loops=1)
+               Filter: (thousand = 0)
+               Rows Removed by Filter: 9990
+         ->  Gather (actual rows=9800 loops=10)
+               Workers Planned: 4
+               Workers Launched: 4
+               ->  Parallel Seq Scan on tenk1 (actual rows=1960 loops=50)
+                     Filter: (hundred > 1)
+                     Rows Removed by Filter: 40
+ Planning time: xxx ms
+ Execution time: xxx ms
+(13 rows)
+
+reset enable_indexscan;
+reset enable_bitmapscan;
+reset enable_material;
+alter table tenk2 reset (parallel_workers);
+drop function explain_parallel_stats();
 -- test the sanity of parallel query after the active role is dropped.
 set force_parallel_mode=1;
 drop role if exists regress_parallel_worker;
diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql
index af0cc55..7defc34 100644
--- a/src/test/regress/sql/select_parallel.sql
+++ b/src/test/regress/sql/select_parallel.sql
@@ -45,6 +45,34 @@ select avg(aa::int8) from a_star;
 
 select avg(aa::int8) from a_star;
 
+-- test accumulation of stats for parallel nodes
+set enable_indexscan to off;
+set enable_bitmapscan to off;
+set enable_material to off;
+alter table tenk2 set (parallel_workers = 0);
+create function explain_parallel_stats() returns setof text
+language plpgsql as
+$$
+declare ln text;
+begin
+    for ln in
+        explain (analyze, timing off, costs off)
+          select count(*) from tenk1, tenk2 where
+            tenk1.hundred > 1 and tenk2.thousand=0
+    loop
+        ln := regexp_replace(ln, 'Planning time: \S*',  'Planning time: xxx');
+        ln := regexp_replace(ln, 'Execution time: \S*', 'Execution time: xxx');
+        return next ln;
+    end loop;
+end;
+$$;
+select * from explain_parallel_stats();
+reset enable_indexscan;
+reset enable_bitmapscan;
+reset enable_material;
+alter table tenk2 reset (parallel_workers);
+drop function explain_parallel_stats();
+
 -- test the sanity of parallel query after the active role is dropped.
 set force_parallel_mode=1;
 drop role if exists regress_parallel_worker;