Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commitbf11e7e

Browse files
committed
Propagate sort instrumentation from workers back to leader.
Up until now, when parallel query was used, no details about thesort method or space used by the workers were available; detailswere shown only for any sorting done by the leader. Fix that.Commit1177ab1 forced the test caseadded by commit1f6d515 to runwithout parallelism; now that we have this infrastructure, allowthat again, with a little tweaking to make it pass with and withoutforce_parallel_mode.Robert Haas and Tom LaneDiscussion:http://postgr.es/m/CA+Tgmoa2VBZW6S8AAXfhpHczb=Rf6RqQ2br+zJvEgwJ0uoD_tQ@mail.gmail.com
1 parent3452dc5 commitbf11e7e

File tree

9 files changed

+342
-87
lines changed

9 files changed

+342
-87
lines changed

‎src/backend/commands/explain.c‎

Lines changed: 54 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2292,15 +2292,21 @@ show_tablesample(TableSampleClause *tsc, PlanState *planstate,
22922292
staticvoid
22932293
show_sort_info(SortState*sortstate,ExplainState*es)
22942294
{
2295-
if (es->analyze&&sortstate->sort_Done&&
2296-
sortstate->tuplesortstate!=NULL)
2295+
if (!es->analyze)
2296+
return;
2297+
2298+
if (sortstate->sort_Done&&sortstate->tuplesortstate!=NULL)
22972299
{
22982300
Tuplesortstate*state= (Tuplesortstate*)sortstate->tuplesortstate;
2301+
TuplesortInstrumentationstats;
22992302
constchar*sortMethod;
23002303
constchar*spaceType;
23012304
longspaceUsed;
23022305

2303-
tuplesort_get_stats(state,&sortMethod,&spaceType,&spaceUsed);
2306+
tuplesort_get_stats(state,&stats);
2307+
sortMethod=tuplesort_method_name(stats.sortMethod);
2308+
spaceType=tuplesort_space_type_name(stats.spaceType);
2309+
spaceUsed=stats.spaceUsed;
23042310

23052311
if (es->format==EXPLAIN_FORMAT_TEXT)
23062312
{
@@ -2315,6 +2321,51 @@ show_sort_info(SortState *sortstate, ExplainState *es)
23152321
ExplainPropertyText("Sort Space Type",spaceType,es);
23162322
}
23172323
}
2324+
2325+
if (sortstate->shared_info!=NULL)
2326+
{
2327+
intn;
2328+
boolopened_group= false;
2329+
2330+
for (n=0;n<sortstate->shared_info->num_workers;n++)
2331+
{
2332+
TuplesortInstrumentation*sinstrument;
2333+
constchar*sortMethod;
2334+
constchar*spaceType;
2335+
longspaceUsed;
2336+
2337+
sinstrument=&sortstate->shared_info->sinstrument[n];
2338+
if (sinstrument->sortMethod==SORT_TYPE_STILL_IN_PROGRESS)
2339+
continue;/* ignore any unfilled slots */
2340+
sortMethod=tuplesort_method_name(sinstrument->sortMethod);
2341+
spaceType=tuplesort_space_type_name(sinstrument->spaceType);
2342+
spaceUsed=sinstrument->spaceUsed;
2343+
2344+
if (es->format==EXPLAIN_FORMAT_TEXT)
2345+
{
2346+
appendStringInfoSpaces(es->str,es->indent*2);
2347+
appendStringInfo(es->str,
2348+
"Worker %d: Sort Method: %s %s: %ldkB\n",
2349+
n,sortMethod,spaceType,spaceUsed);
2350+
}
2351+
else
2352+
{
2353+
if (!opened_group)
2354+
{
2355+
ExplainOpenGroup("Workers","Workers", false,es);
2356+
opened_group= true;
2357+
}
2358+
ExplainOpenGroup("Worker",NULL, true,es);
2359+
ExplainPropertyInteger("Worker Number",n,es);
2360+
ExplainPropertyText("Sort Method",sortMethod,es);
2361+
ExplainPropertyLong("Sort Space Used",spaceUsed,es);
2362+
ExplainPropertyText("Sort Space Type",spaceType,es);
2363+
ExplainCloseGroup("Worker",NULL, true,es);
2364+
}
2365+
}
2366+
if (opened_group)
2367+
ExplainCloseGroup("Workers","Workers", false,es);
2368+
}
23182369
}
23192370

23202371
/*

‎src/backend/executor/execParallel.c‎

Lines changed: 89 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -28,9 +28,10 @@
2828
#include"executor/nodeBitmapHeapscan.h"
2929
#include"executor/nodeCustom.h"
3030
#include"executor/nodeForeignscan.h"
31-
#include"executor/nodeSeqscan.h"
3231
#include"executor/nodeIndexscan.h"
3332
#include"executor/nodeIndexonlyscan.h"
33+
#include"executor/nodeSeqscan.h"
34+
#include"executor/nodeSort.h"
3435
#include"executor/tqueue.h"
3536
#include"nodes/nodeFuncs.h"
3637
#include"optimizer/planmain.h"
@@ -202,10 +203,10 @@ ExecSerializePlan(Plan *plan, EState *estate)
202203
}
203204

204205
/*
205-
*Ordinary plan nodeswon't do anything here, but parallel-aware plan nodes
206-
*may need some statewhich is shared across all parallel workers. Before
207-
*we size the DSM, givethem a chance to call shm_toc_estimate_chunk or
208-
*shm_toc_estimate_keys on&pcxt->estimator.
206+
*Parallel-aware plan nodes(and occasionally others) may need some state
207+
* which is shared across all parallel workers. Before we size the DSM, give
208+
* them a chance to call shm_toc_estimate_chunk or shm_toc_estimate_keys on
209+
* &pcxt->estimator.
209210
*
210211
* While we're at it, count the number of PlanState nodes in the tree, so
211212
* we know how many SharedPlanStateInstrumentation structures we need.
@@ -219,38 +220,43 @@ ExecParallelEstimate(PlanState *planstate, ExecParallelEstimateContext *e)
219220
/* Count this node. */
220221
e->nnodes++;
221222

222-
/* Call estimators for parallel-aware nodes. */
223-
if (planstate->plan->parallel_aware)
223+
switch (nodeTag(planstate))
224224
{
225-
switch (nodeTag(planstate))
226-
{
227-
caseT_SeqScanState:
225+
caseT_SeqScanState:
226+
if (planstate->plan->parallel_aware)
228227
ExecSeqScanEstimate((SeqScanState*)planstate,
229228
e->pcxt);
230-
break;
231-
caseT_IndexScanState:
229+
break;
230+
caseT_IndexScanState:
231+
if (planstate->plan->parallel_aware)
232232
ExecIndexScanEstimate((IndexScanState*)planstate,
233233
e->pcxt);
234-
break;
235-
caseT_IndexOnlyScanState:
234+
break;
235+
caseT_IndexOnlyScanState:
236+
if (planstate->plan->parallel_aware)
236237
ExecIndexOnlyScanEstimate((IndexOnlyScanState*)planstate,
237238
e->pcxt);
238-
break;
239-
caseT_ForeignScanState:
239+
break;
240+
caseT_ForeignScanState:
241+
if (planstate->plan->parallel_aware)
240242
ExecForeignScanEstimate((ForeignScanState*)planstate,
241243
e->pcxt);
242-
break;
243-
caseT_CustomScanState:
244+
break;
245+
caseT_CustomScanState:
246+
if (planstate->plan->parallel_aware)
244247
ExecCustomScanEstimate((CustomScanState*)planstate,
245248
e->pcxt);
246-
break;
247-
caseT_BitmapHeapScanState:
249+
break;
250+
caseT_BitmapHeapScanState:
251+
if (planstate->plan->parallel_aware)
248252
ExecBitmapHeapEstimate((BitmapHeapScanState*)planstate,
249253
e->pcxt);
250-
break;
251-
default:
252-
break;
253-
}
254+
break;
255+
caseT_SortState:
256+
/* even when not parallel-aware */
257+
ExecSortEstimate((SortState*)planstate,e->pcxt);
258+
default:
259+
break;
254260
}
255261

256262
returnplanstate_tree_walker(planstate,ExecParallelEstimate,e);
@@ -276,46 +282,51 @@ ExecParallelInitializeDSM(PlanState *planstate,
276282
d->nnodes++;
277283

278284
/*
279-
* Call initializers forparallel-aware plan nodes.
285+
* Call initializers forDSM-using plan nodes.
280286
*
281-
*Ordinary plan nodes won't do anything here, butparallel-awareplan
282-
*nodes may need to initialize shared state in the DSM before parallel
283-
* workers areavailable. They can allocate the space they previously
287+
*Most plan nodes won't do anything here, but plan nodes that allocated
288+
*DSM may need to initialize shared state in the DSM before parallel
289+
* workers arelaunched. They can allocate the space they previously
284290
* estimated using shm_toc_allocate, and add the keys they previously
285291
* estimated using shm_toc_insert, in each case targeting pcxt->toc.
286292
*/
287-
if (planstate->plan->parallel_aware)
293+
switch (nodeTag(planstate))
288294
{
289-
switch (nodeTag(planstate))
290-
{
291-
caseT_SeqScanState:
295+
caseT_SeqScanState:
296+
if (planstate->plan->parallel_aware)
292297
ExecSeqScanInitializeDSM((SeqScanState*)planstate,
293298
d->pcxt);
294-
break;
295-
caseT_IndexScanState:
299+
break;
300+
caseT_IndexScanState:
301+
if (planstate->plan->parallel_aware)
296302
ExecIndexScanInitializeDSM((IndexScanState*)planstate,
297303
d->pcxt);
298-
break;
299-
caseT_IndexOnlyScanState:
304+
break;
305+
caseT_IndexOnlyScanState:
306+
if (planstate->plan->parallel_aware)
300307
ExecIndexOnlyScanInitializeDSM((IndexOnlyScanState*)planstate,
301308
d->pcxt);
302-
break;
303-
caseT_ForeignScanState:
309+
break;
310+
caseT_ForeignScanState:
311+
if (planstate->plan->parallel_aware)
304312
ExecForeignScanInitializeDSM((ForeignScanState*)planstate,
305313
d->pcxt);
306-
break;
307-
caseT_CustomScanState:
314+
break;
315+
caseT_CustomScanState:
316+
if (planstate->plan->parallel_aware)
308317
ExecCustomScanInitializeDSM((CustomScanState*)planstate,
309318
d->pcxt);
310-
break;
311-
caseT_BitmapHeapScanState:
319+
break;
320+
caseT_BitmapHeapScanState:
321+
if (planstate->plan->parallel_aware)
312322
ExecBitmapHeapInitializeDSM((BitmapHeapScanState*)planstate,
313323
d->pcxt);
314-
break;
315-
316-
default:
317-
break;
318-
}
324+
break;
325+
caseT_SortState:
326+
/* even when not parallel-aware */
327+
ExecSortInitializeDSM((SortState*)planstate,d->pcxt);
328+
default:
329+
break;
319330
}
320331

321332
returnplanstate_tree_walker(planstate,ExecParallelInitializeDSM,d);
@@ -642,6 +653,13 @@ ExecParallelRetrieveInstrumentation(PlanState *planstate,
642653
planstate->worker_instrument->num_workers=instrumentation->num_workers;
643654
memcpy(&planstate->worker_instrument->instrument,instrument,ibytes);
644655

656+
/*
657+
* Perform any node-type-specific work that needs to be done. Currently,
658+
* only Sort nodes need to do anything here.
659+
*/
660+
if (IsA(planstate,SortState))
661+
ExecSortRetrieveInstrumentation((SortState*)planstate);
662+
645663
returnplanstate_tree_walker(planstate,ExecParallelRetrieveInstrumentation,
646664
instrumentation);
647665
}
@@ -801,35 +819,40 @@ ExecParallelInitializeWorker(PlanState *planstate, shm_toc *toc)
801819
if (planstate==NULL)
802820
return false;
803821

804-
/* Call initializers for parallel-aware plan nodes. */
805-
if (planstate->plan->parallel_aware)
822+
switch (nodeTag(planstate))
806823
{
807-
switch (nodeTag(planstate))
808-
{
809-
caseT_SeqScanState:
824+
caseT_SeqScanState:
825+
if (planstate->plan->parallel_aware)
810826
ExecSeqScanInitializeWorker((SeqScanState*)planstate,toc);
811-
break;
812-
caseT_IndexScanState:
827+
break;
828+
caseT_IndexScanState:
829+
if (planstate->plan->parallel_aware)
813830
ExecIndexScanInitializeWorker((IndexScanState*)planstate,toc);
814-
break;
815-
caseT_IndexOnlyScanState:
831+
break;
832+
caseT_IndexOnlyScanState:
833+
if (planstate->plan->parallel_aware)
816834
ExecIndexOnlyScanInitializeWorker((IndexOnlyScanState*)planstate,toc);
817-
break;
818-
caseT_ForeignScanState:
835+
break;
836+
caseT_ForeignScanState:
837+
if (planstate->plan->parallel_aware)
819838
ExecForeignScanInitializeWorker((ForeignScanState*)planstate,
820839
toc);
821-
break;
822-
caseT_CustomScanState:
840+
break;
841+
caseT_CustomScanState:
842+
if (planstate->plan->parallel_aware)
823843
ExecCustomScanInitializeWorker((CustomScanState*)planstate,
824844
toc);
825-
break;
826-
caseT_BitmapHeapScanState:
845+
break;
846+
caseT_BitmapHeapScanState:
847+
if (planstate->plan->parallel_aware)
827848
ExecBitmapHeapInitializeWorker(
828849
(BitmapHeapScanState*)planstate,toc);
829-
break;
830-
default:
831-
break;
832-
}
850+
break;
851+
caseT_SortState:
852+
/* even when not parallel-aware */
853+
ExecSortInitializeWorker((SortState*)planstate,toc);
854+
default:
855+
break;
833856
}
834857

835858
returnplanstate_tree_walker(planstate,ExecParallelInitializeWorker,toc);

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp