execParallel.c Source File (original) (raw)

59#define PARALLEL_KEY_EXECUTOR_FIXED UINT64CONST(0xE000000000000001)

60#define PARALLEL_KEY_PLANNEDSTMT UINT64CONST(0xE000000000000002)

61#define PARALLEL_KEY_PARAMLISTINFO UINT64CONST(0xE000000000000003)

62#define PARALLEL_KEY_BUFFER_USAGE UINT64CONST(0xE000000000000004)

63#define PARALLEL_KEY_TUPLE_QUEUE UINT64CONST(0xE000000000000005)

64#define PARALLEL_KEY_INSTRUMENTATION UINT64CONST(0xE000000000000006)

65#define PARALLEL_KEY_DSA UINT64CONST(0xE000000000000007)

66#define PARALLEL_KEY_QUERY_TEXT UINT64CONST(0xE000000000000008)

67#define PARALLEL_KEY_JIT_INSTRUMENTATION UINT64CONST(0xE000000000000009)

68#define PARALLEL_KEY_WAL_USAGE UINT64CONST(0xE00000000000000A)

70#define PARALLEL_TUPLE_QUEUE_SIZE 65536

76{

100{

106

107};

108#define GetInstrumentationArray(sei) \

109 (AssertVariableIsOfTypeMacro(sei, SharedExecutorInstrumentation *), \

110 (Instrumentation *) (((char *) sei) + sei->instrument_offset))

111

112

114{

118

119

121{

126

127

134 bool reinitialize);

139

140

142

143

144

145

146static char *

148{

151

152

154

155

156

157

158

159

160

161

162

163

164 foreach(lc, plan->targetlist)

165 {

167

168 tle->resjunk = false;

169 }

170

171

172

173

174

175

194

195

196

197

198

199

200

201

204 {

206

208 subplan = NULL;

210 }

211

215 pstmt->invalItems = NIL;

220

221

223}

224

225

226

227

228

229

230

231

232

233

234static bool

236{

237 if (planstate == NULL)

238 return false;

239

240

241 e->nnodes++;

242

243 switch (nodeTag(planstate))

244 {

245 case T_SeqScanState:

248 e->pcxt);

249 break;

250 case T_IndexScanState:

251

253 e->pcxt);

254 break;

255 case T_IndexOnlyScanState:

256

258 e->pcxt);

259 break;

260 case T_BitmapIndexScanState:

261

263 e->pcxt);

264 break;

265 case T_ForeignScanState:

266 if (planstate->plan->parallel_aware)

268 e->pcxt);

269 break;

270 case T_TidRangeScanState:

271 if (planstate->plan->parallel_aware)

273 e->pcxt);

274 break;

275 case T_AppendState:

276 if (planstate->plan->parallel_aware)

278 e->pcxt);

279 break;

280 case T_CustomScanState:

281 if (planstate->plan->parallel_aware)

283 e->pcxt);

284 break;

285 case T_BitmapHeapScanState:

286 if (planstate->plan->parallel_aware)

288 e->pcxt);

289 break;

290 case T_HashJoinState:

291 if (planstate->plan->parallel_aware)

293 e->pcxt);

294 break;

295 case T_HashState:

296

298 break;

299 case T_SortState:

300

302 break;

303 case T_IncrementalSortState:

304

306 break;

307 case T_AggState:

308

310 break;

311 case T_MemoizeState:

312

314 break;

315 default:

316 break;

317 }

318

320}

321

322

323

324

327{

328 int paramid;

329 Size sz = sizeof(int);

330

331 paramid = -1;

332 while ((paramid = bms_next_member(params, paramid)) >= 0)

333 {

334 Oid typeOid;

336 bool typByVal;

338

341 paramid);

342

343 sz = add_size(sz, sizeof(int));

344

345

348 else

349 {

350

351 typLen = sizeof(Datum);

352 typByVal = true;

353 }

356 typByVal, typLen));

357 }

358 return sz;

359}

360

361

362

363

364

365

366

367

368

371{

373 int nparams;

374 int paramid;

377 char *start_address;

378

379

383

384

386 memcpy(start_address, &nparams, sizeof(int));

387 start_address += sizeof(int);

388

389

390 paramid = -1;

391 while ((paramid = bms_next_member(params, paramid)) >= 0)

392 {

393 Oid typeOid;

395 bool typByVal;

396

399 paramid);

400

401

402 memcpy(start_address, &paramid, sizeof(int));

403 start_address += sizeof(int);

404

405

408 else

409 {

410

411 typLen = sizeof(Datum);

412 typByVal = true;

413 }

415 &start_address);

416 }

417

418 return handle;

419}

420

421

422

423

424static void

426{

427 int nparams;

428 int i;

429 int paramid;

430

431 memcpy(&nparams, start_address, sizeof(int));

432 start_address += sizeof(int);

433

434 for (i = 0; i < nparams; i++)

435 {

437

438

439 memcpy(&paramid, start_address, sizeof(int));

440 start_address += sizeof(int);

442

443

446 }

447}

448

449

450

451

452

453static bool

456{

457 if (planstate == NULL)

458 return false;

459

460

464

465

467

468

469

470

471

472

473

474

475

476

477 switch (nodeTag(planstate))

478 {

479 case T_SeqScanState:

483 break;

484 case T_IndexScanState:

485

487 break;

488 case T_IndexOnlyScanState:

489

492 break;

493 case T_BitmapIndexScanState:

494

496 break;

497 case T_ForeignScanState:

498 if (planstate->plan->parallel_aware)

501 break;

502 case T_TidRangeScanState:

503 if (planstate->plan->parallel_aware)

506 break;

507 case T_AppendState:

508 if (planstate->plan->parallel_aware)

511 break;

512 case T_CustomScanState:

513 if (planstate->plan->parallel_aware)

516 break;

517 case T_BitmapHeapScanState:

518 if (planstate->plan->parallel_aware)

521 break;

522 case T_HashJoinState:

523 if (planstate->plan->parallel_aware)

526 break;

527 case T_HashState:

528

530 break;

531 case T_SortState:

532

534 break;

535 case T_IncrementalSortState:

536

538 break;

539 case T_AggState:

540

542 break;

543 case T_MemoizeState:

544

546 break;

547 default:

548 break;

549 }

550

552}

553

554

555

556

557

560{

562 char *tqueuespace;

563 int i;

564

565

567 return NULL;

568

569

572

573

574

575

576

577 if (!reinitialize)

578 tqueuespace =

582 else

584

585

587 {

589

593

596 }

597

598

599 if (!reinitialize)

601

602

603 return responseq;

604}

605

606

607

608

609

612 Bitmapset *sendParams, int nworkers,

613 int64 tuples_needed)

614{

620 char *pstmt_data;

621 char *pstmt_space;

622 char *paramlistinfo_space;

627 int pstmt_len;

628 int paramlistinfo_len;

629 int instrumentation_len = 0;

630 int jit_instrumentation_len = 0;

631 int instrument_offset = 0;

633 char *query_string;

634 int query_len;

635

636

637

638

639

640

641

642

643

644

645

646

648

649

653

654

656

657

659 pei->pcxt = pcxt;

660

661

662

663

664

665

666

667

671

672

676

677

678 pstmt_len = strlen(pstmt_data) + 1;

681

682

686

687

688

689

690

691

692

693

697

698

699

700

704

705

709

710

711

712

713

714 e.pcxt = pcxt;

715 e.nnodes = 0;

717

718

720 {

721 instrumentation_len =

723 sizeof(int) * e.nnodes;

724 instrumentation_len = MAXALIGN(instrumentation_len);

725 instrument_offset = instrumentation_len;

726 instrumentation_len +=

731

732

734 {

735 jit_instrumentation_len =

740 }

741 }

742

743

746

747

748

749

750

751

753

754

756

757

758

759

760

761

762

763

764

765

772

773

775 memcpy(query_string, estate->es_sourceText, query_len + 1);

777

778

780 memcpy(pstmt_space, pstmt_data, pstmt_len);

782

783

787

788

793

794

799

800

802

803

805

806

807

808

809

810

812 {

814 int i;

815

822 for (i = 0; i < nworkers * e.nnodes; ++i)

825 instrumentation);

827

829 {

831 jit_instrumentation_len);

832 jit_instrumentation->num_workers = nworkers;

833 memset(jit_instrumentation->jit_instr, 0,

836 jit_instrumentation);

838 }

839 }

840

841

842

843

844

845

846 if (pcxt->seg != NULL)

847 {

848 char *area_space;

849

853 LWTRANCHE_PARALLEL_QUERY_DSA,

854 pcxt->seg);

855

856

857

858

859

860

861

863 {

867 }

868 }

869

870

871

872

873

874

875 d.pcxt = pcxt;

878

879

883

884

885

886

887

888 if (e.nnodes != d.nnodes)

889 elog(ERROR, "inconsistent count of PlanState nodes");

890

891

892 return pei;

893}

894

895

896

897

898

899

900

901void

903{

905 int i;

906

908

909 if (nworkers > 0)

910 {

913

914 for (i = 0; i < nworkers; i++)

915 {

919 }

920 }

921}

922

923

924

925

926

927void

931{

934

935

937

938

939

940

941

942

944

949

951

952

954 {

957 }

958

959

961 {

965 }

966

967

971}

972

973

974

975

976static bool

979{

980 if (planstate == NULL)

981 return false;

982

983

984

985

986 switch (nodeTag(planstate))

987 {

988 case T_SeqScanState:

991 pcxt);

992 break;

993 case T_IndexScanState:

994 if (planstate->plan->parallel_aware)

996 pcxt);

997 break;

998 case T_IndexOnlyScanState:

999 if (planstate->plan->parallel_aware)

1001 pcxt);

1002 break;

1003 case T_ForeignScanState:

1004 if (planstate->plan->parallel_aware)

1006 pcxt);

1007 break;

1008 case T_TidRangeScanState:

1009 if (planstate->plan->parallel_aware)

1011 pcxt);

1012 break;

1013 case T_AppendState:

1014 if (planstate->plan->parallel_aware)

1016 break;

1017 case T_CustomScanState:

1018 if (planstate->plan->parallel_aware)

1020 pcxt);

1021 break;

1022 case T_BitmapHeapScanState:

1023 if (planstate->plan->parallel_aware)

1025 pcxt);

1026 break;

1027 case T_HashJoinState:

1028 if (planstate->plan->parallel_aware)

1030 pcxt);

1031 break;

1032 case T_BitmapIndexScanState:

1033 case T_HashState:

1034 case T_SortState:

1035 case T_IncrementalSortState:

1036 case T_MemoizeState:

1037

1038 break;

1039

1040 default:

1041 break;

1042 }

1043

1045}

1046

1047

1048

1049

1050

1051static bool

1054{

1056 int i;

1057 int n;

1058 int ibytes;

1061

1062

1064 if (instrumentation->plan_node_id[i] == plan_node_id)

1065 break;

1067 elog(ERROR, "plan node %d not found", plan_node_id);

1068

1069

1071 instrument += i * instrumentation->num_workers;

1072 for (n = 0; n < instrumentation->num_workers; ++n)

1074

1075

1076

1077

1078

1079

1080

1081

1087

1090

1091

1092 switch (nodeTag(planstate))

1093 {

1094 case T_IndexScanState:

1096 break;

1097 case T_IndexOnlyScanState:

1099 break;

1100 case T_BitmapIndexScanState:

1102 break;

1103 case T_SortState:

1105 break;

1106 case T_IncrementalSortState:

1108 break;

1109 case T_HashState:

1111 break;

1112 case T_AggState:

1114 break;

1115 case T_MemoizeState:

1117 break;

1118 case T_BitmapHeapScanState:

1120 break;

1121 default:

1122 break;

1123 }

1124

1126 instrumentation);

1127}

1128

1129

1130

1131

1132static void

1135{

1137 int ibytes;

1138

1139 int n;

1140

1141

1142

1143

1144

1149

1150

1151 for (n = 0; n < shared_jit->num_workers; ++n)

1153

1154

1155

1156

1157

1158

1159

1164

1166}

1167

1168

1169

1170

1171

1172void

1174{

1176 int i;

1177

1178

1180 return;

1181

1182

1183

1184

1185

1186 if (pei->tqueue != NULL)

1187 {

1188 for (i = 0; i < nworkers; i++)

1192 }

1193

1194

1195

1196

1197

1198 if (pei->reader != NULL)

1199 {

1200 for (i = 0; i < nworkers; i++)

1204 }

1205

1206

1208

1209

1210

1211

1212

1213 for (i = 0; i < nworkers; i++)

1215

1217}

1218

1219

1220

1221

1222

1223

1224

1225void

1227{

1228

1232

1233

1237

1238

1240 {

1243 }

1244 if (pei->area != NULL)

1245 {

1247 pei->area = NULL;

1248 }

1249 if (pei->pcxt != NULL)

1250 {

1252 pei->pcxt = NULL;

1253 }

1255}

1256

1257

1258

1259

1260

1263{

1264 char *mqspace;

1266

1269 mq = (shm_mq *) mqspace;

1272}

1273

1274

1275

1276

1279 int instrument_options)

1280{

1281 char *pstmtspace;

1282 char *paramspace;

1285 char *queryString;

1286

1287

1289

1290

1293

1294

1297

1298

1300 queryString,

1302 receiver, paramLI, NULL, instrument_options);

1303}

1304

1305

1306

1307

1308

1309static bool

1312{

1313 int i;

1316

1318

1319

1320

1321

1322

1323

1324

1326 if (instrumentation->plan_node_id[i] == plan_node_id)

1327 break;

1329 elog(ERROR, "plan node %d not found", plan_node_id);

1330

1331

1332

1333

1334

1336 instrument += i * instrumentation->num_workers;

1338 Assert(ParallelWorkerNumber < instrumentation->num_workers);

1340

1342 instrumentation);

1343}

1344

1345

1346

1347

1348

1349

1350static bool

1352{

1353 if (planstate == NULL)

1354 return false;

1355

1356 switch (nodeTag(planstate))

1357 {

1358 case T_SeqScanState:

1361 break;

1362 case T_IndexScanState:

1363

1365 break;

1366 case T_IndexOnlyScanState:

1367

1369 pwcxt);

1370 break;

1371 case T_BitmapIndexScanState:

1372

1374 pwcxt);

1375 break;

1376 case T_ForeignScanState:

1377 if (planstate->plan->parallel_aware)

1379 pwcxt);

1380 break;

1381 case T_TidRangeScanState:

1382 if (planstate->plan->parallel_aware)

1384 pwcxt);

1385 break;

1386 case T_AppendState:

1387 if (planstate->plan->parallel_aware)

1389 break;

1390 case T_CustomScanState:

1391 if (planstate->plan->parallel_aware)

1393 pwcxt);

1394 break;

1395 case T_BitmapHeapScanState:

1396 if (planstate->plan->parallel_aware)

1398 pwcxt);

1399 break;

1400 case T_HashJoinState:

1401 if (planstate->plan->parallel_aware)

1403 pwcxt);

1404 break;

1405 case T_HashState:

1406

1408 break;

1409 case T_SortState:

1410

1412 break;

1413 case T_IncrementalSortState:

1414

1416 pwcxt);

1417 break;

1418 case T_AggState:

1419

1421 break;

1422 case T_MemoizeState:

1423

1425 break;

1426 default:

1427 break;

1428 }

1429

1431 pwcxt);

1432}

1433

1434

1435

1436

1437

1438

1439

1440

1441

1442

1443

1444

1445

1446

1447

1448

1449

1450void

1452{

1460 int instrument_options = 0;

1461 void *area_space;

1464

1465

1467

1468

1471 if (instrumentation != NULL)

1474 true);

1476

1477

1479

1480

1482

1483

1486

1487

1490

1491

1494 {

1495 char *paramexec_space;

1496

1499 }

1500 pwcxt.toc = toc;

1501 pwcxt.seg = seg;

1503

1504

1506

1507

1508

1509

1510

1511

1512

1513

1515

1516

1517

1518

1519

1523

1524

1526

1527

1532

1533

1534 if (instrumentation != NULL)

1536 instrumentation);

1537

1538

1539 if (queryDesc->estate->es_jit && jit_instrumentation != NULL)

1540 {

1541 Assert(ParallelWorkerNumber < jit_instrumentation->num_workers);

1544 }

1545

1546

1548

1549

1552 receiver->rDestroy(receiver);

1553}

void InitializeParallelDSM(ParallelContext *pcxt)

void WaitForParallelWorkersToFinish(ParallelContext *pcxt)

void ReinitializeParallelDSM(ParallelContext *pcxt)

void DestroyParallelContext(ParallelContext *pcxt)

ParallelContext * CreateParallelContext(const char *library_name, const char *function_name, int nworkers)

int64 pgstat_get_my_query_id(void)

void pgstat_report_activity(BackendState state, const char *cmd_str)

int64 pgstat_get_my_plan_id(void)

int bms_next_member(const Bitmapset *a, int prevbit)

int bms_num_members(const Bitmapset *a)

#define FLEXIBLE_ARRAY_MEMBER

#define OidIsValid(objectId)

Datum datumRestore(char **start_address, bool *isnull)

void datumSerialize(Datum value, bool isnull, bool typByVal, int typLen, char **start_address)

Size datumEstimateSpace(Datum value, bool isnull, bool typByVal, int typLen)

dsa_area * dsa_attach_in_place(void *place, dsm_segment *segment)

void * dsa_get_address(dsa_area *area, dsa_pointer dp)

void dsa_detach(dsa_area *area)

void dsa_free(dsa_area *area, dsa_pointer dp)

size_t dsa_minimum_size(void)

#define dsa_allocate(area, size)

#define dsa_create_in_place(place, size, tranche_id, segment)

#define InvalidDsaPointer

#define DsaPointerIsValid(x)

void ExecutorEnd(QueryDesc *queryDesc)

void ExecutorFinish(QueryDesc *queryDesc)

void ExecutorStart(QueryDesc *queryDesc, int eflags)

void ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count)

#define PARALLEL_KEY_BUFFER_USAGE

static bool ExecParallelReInitializeDSM(PlanState *planstate, ParallelContext *pcxt)

#define PARALLEL_KEY_JIT_INSTRUMENTATION

struct ExecParallelEstimateContext ExecParallelEstimateContext

#define PARALLEL_KEY_PARAMLISTINFO

#define PARALLEL_TUPLE_QUEUE_SIZE

static QueryDesc * ExecParallelGetQueryDesc(shm_toc *toc, DestReceiver *receiver, int instrument_options)

static bool ExecParallelRetrieveInstrumentation(PlanState *planstate, SharedExecutorInstrumentation *instrumentation)

static dsa_pointer SerializeParamExecParams(EState *estate, Bitmapset *params, dsa_area *area)

void ExecParallelCleanup(ParallelExecutorInfo *pei)

struct ExecParallelInitializeDSMContext ExecParallelInitializeDSMContext

#define PARALLEL_KEY_INSTRUMENTATION

static DestReceiver * ExecParallelGetReceiver(dsm_segment *seg, shm_toc *toc)

void ParallelQueryMain(dsm_segment *seg, shm_toc *toc)

static shm_mq_handle ** ExecParallelSetupTupleQueues(ParallelContext *pcxt, bool reinitialize)

#define PARALLEL_KEY_PLANNEDSTMT

static bool ExecParallelEstimate(PlanState *planstate, ExecParallelEstimateContext *e)

#define GetInstrumentationArray(sei)

void ExecParallelReinitialize(PlanState *planstate, ParallelExecutorInfo *pei, Bitmapset *sendParams)

static bool ExecParallelInitializeWorker(PlanState *planstate, ParallelWorkerContext *pwcxt)

void ExecParallelCreateReaders(ParallelExecutorInfo *pei)

#define PARALLEL_KEY_TUPLE_QUEUE

#define PARALLEL_KEY_EXECUTOR_FIXED

static char * ExecSerializePlan(Plan *plan, EState *estate)

ParallelExecutorInfo * ExecInitParallelPlan(PlanState *planstate, EState *estate, Bitmapset *sendParams, int nworkers, int64 tuples_needed)

struct FixedParallelExecutorState FixedParallelExecutorState

#define PARALLEL_KEY_QUERY_TEXT

static Size EstimateParamExecSpace(EState *estate, Bitmapset *params)

void ExecParallelFinish(ParallelExecutorInfo *pei)

static bool ExecParallelReportInstrumentation(PlanState *planstate, SharedExecutorInstrumentation *instrumentation)

#define PARALLEL_KEY_WAL_USAGE

static void ExecParallelRetrieveJitInstrumentation(PlanState *planstate, SharedJitInstrumentation *shared_jit)

static bool ExecParallelInitializeDSM(PlanState *planstate, ExecParallelInitializeDSMContext *d)

static void RestoreParamExecParams(char *start_address, EState *estate)

void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)

#define GetPerTupleExprContext(estate)

#define palloc0_object(type)

Assert(PointerIsAligned(start, uint64))

#define IsParallelWorker()

void InstrAccumParallelQuery(BufferUsage *bufusage, WalUsage *walusage)

void InstrEndLoop(Instrumentation *instr)

void InstrAggNode(Instrumentation *dst, Instrumentation *add)

void InstrEndParallelQuery(BufferUsage *bufusage, WalUsage *walusage)

void InstrStartParallelQuery(void)

void InstrInit(Instrumentation *instr, int instrument_options)

void InstrJitAgg(JitInstrumentation *dst, JitInstrumentation *add)

struct JitInstrumentation JitInstrumentation

List * lappend(List *list, void *datum)

void get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)

void * MemoryContextAlloc(MemoryContext context, Size size)

void * MemoryContextAllocZero(MemoryContext context, Size size)

void pfree(void *pointer)

void ExecAggEstimate(AggState *node, ParallelContext *pcxt)

void ExecAggInitializeWorker(AggState *node, ParallelWorkerContext *pwcxt)

void ExecAggRetrieveInstrumentation(AggState *node)

void ExecAggInitializeDSM(AggState *node, ParallelContext *pcxt)

void ExecAppendReInitializeDSM(AppendState *node, ParallelContext *pcxt)

void ExecAppendInitializeWorker(AppendState *node, ParallelWorkerContext *pwcxt)

void ExecAppendInitializeDSM(AppendState *node, ParallelContext *pcxt)

void ExecAppendEstimate(AppendState *node, ParallelContext *pcxt)

void ExecBitmapHeapInitializeWorker(BitmapHeapScanState *node, ParallelWorkerContext *pwcxt)

void ExecBitmapHeapEstimate(BitmapHeapScanState *node, ParallelContext *pcxt)

void ExecBitmapHeapRetrieveInstrumentation(BitmapHeapScanState *node)

void ExecBitmapHeapInitializeDSM(BitmapHeapScanState *node, ParallelContext *pcxt)

void ExecBitmapHeapReInitializeDSM(BitmapHeapScanState *node, ParallelContext *pcxt)

void ExecBitmapIndexScanEstimate(BitmapIndexScanState *node, ParallelContext *pcxt)

void ExecBitmapIndexScanInitializeDSM(BitmapIndexScanState *node, ParallelContext *pcxt)

void ExecBitmapIndexScanRetrieveInstrumentation(BitmapIndexScanState *node)

void ExecBitmapIndexScanInitializeWorker(BitmapIndexScanState *node, ParallelWorkerContext *pwcxt)

void ExecCustomScanInitializeDSM(CustomScanState *node, ParallelContext *pcxt)

void ExecCustomScanEstimate(CustomScanState *node, ParallelContext *pcxt)

void ExecCustomScanReInitializeDSM(CustomScanState *node, ParallelContext *pcxt)

void ExecCustomScanInitializeWorker(CustomScanState *node, ParallelWorkerContext *pwcxt)

void ExecForeignScanInitializeDSM(ForeignScanState *node, ParallelContext *pcxt)

void ExecForeignScanReInitializeDSM(ForeignScanState *node, ParallelContext *pcxt)

void ExecForeignScanEstimate(ForeignScanState *node, ParallelContext *pcxt)

void ExecForeignScanInitializeWorker(ForeignScanState *node, ParallelWorkerContext *pwcxt)

#define planstate_tree_walker(ps, w, c)

void ExecHashInitializeDSM(HashState *node, ParallelContext *pcxt)

void ExecHashInitializeWorker(HashState *node, ParallelWorkerContext *pwcxt)

void ExecHashEstimate(HashState *node, ParallelContext *pcxt)

void ExecHashRetrieveInstrumentation(HashState *node)

void ExecHashJoinInitializeDSM(HashJoinState *state, ParallelContext *pcxt)

void ExecHashJoinEstimate(HashJoinState *state, ParallelContext *pcxt)

void ExecHashJoinReInitializeDSM(HashJoinState *state, ParallelContext *pcxt)

void ExecHashJoinInitializeWorker(HashJoinState *state, ParallelWorkerContext *pwcxt)

void ExecIncrementalSortEstimate(IncrementalSortState *node, ParallelContext *pcxt)

void ExecIncrementalSortInitializeDSM(IncrementalSortState *node, ParallelContext *pcxt)

void ExecIncrementalSortRetrieveInstrumentation(IncrementalSortState *node)

void ExecIncrementalSortInitializeWorker(IncrementalSortState *node, ParallelWorkerContext *pwcxt)

void ExecIndexOnlyScanEstimate(IndexOnlyScanState *node, ParallelContext *pcxt)

void ExecIndexOnlyScanRetrieveInstrumentation(IndexOnlyScanState *node)

void ExecIndexOnlyScanInitializeWorker(IndexOnlyScanState *node, ParallelWorkerContext *pwcxt)

void ExecIndexOnlyScanReInitializeDSM(IndexOnlyScanState *node, ParallelContext *pcxt)

void ExecIndexOnlyScanInitializeDSM(IndexOnlyScanState *node, ParallelContext *pcxt)

void ExecIndexScanRetrieveInstrumentation(IndexScanState *node)

void ExecIndexScanEstimate(IndexScanState *node, ParallelContext *pcxt)

void ExecIndexScanReInitializeDSM(IndexScanState *node, ParallelContext *pcxt)

void ExecIndexScanInitializeDSM(IndexScanState *node, ParallelContext *pcxt)

void ExecIndexScanInitializeWorker(IndexScanState *node, ParallelWorkerContext *pwcxt)

void ExecMemoizeInitializeDSM(MemoizeState *node, ParallelContext *pcxt)

void ExecMemoizeEstimate(MemoizeState *node, ParallelContext *pcxt)

void ExecMemoizeRetrieveInstrumentation(MemoizeState *node)

void ExecMemoizeInitializeWorker(MemoizeState *node, ParallelWorkerContext *pwcxt)

void ExecSeqScanReInitializeDSM(SeqScanState *node, ParallelContext *pcxt)

void ExecSeqScanInitializeWorker(SeqScanState *node, ParallelWorkerContext *pwcxt)

void ExecSeqScanInitializeDSM(SeqScanState *node, ParallelContext *pcxt)

void ExecSeqScanEstimate(SeqScanState *node, ParallelContext *pcxt)

void ExecSortInitializeWorker(SortState *node, ParallelWorkerContext *pwcxt)

void ExecSortEstimate(SortState *node, ParallelContext *pcxt)

void ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt)

void ExecSortRetrieveInstrumentation(SortState *node)

void ExecSetParamPlanMulti(const Bitmapset *params, ExprContext *econtext)

void ExecTidRangeScanEstimate(TidRangeScanState *node, ParallelContext *pcxt)

void ExecTidRangeScanInitializeWorker(TidRangeScanState *node, ParallelWorkerContext *pwcxt)

void ExecTidRangeScanInitializeDSM(TidRangeScanState *node, ParallelContext *pcxt)

void ExecTidRangeScanReInitializeDSM(TidRangeScanState *node, ParallelContext *pcxt)

char * nodeToString(const void *obj)

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

Size EstimateParamListSpace(ParamListInfo paramLI)

void SerializeParamList(ParamListInfo paramLI, char **start_address)

ParamListInfo RestoreParamList(char **start_address)

#define lfirst_node(type, lc)

static Oid list_nth_oid(const List *list, int n)

const char * debug_query_string

void FreeQueryDesc(QueryDesc *qdesc)

QueryDesc * CreateQueryDesc(PlannedStmt *plannedstmt, const char *sourceText, Snapshot snapshot, Snapshot crosscheck_snapshot, DestReceiver *dest, ParamListInfo params, QueryEnvironment *queryEnv, int instrument_options)

void * stringToNode(const char *str)

void shm_mq_set_sender(shm_mq *mq, PGPROC *proc)

shm_mq * shm_mq_create(void *address, Size size)

void shm_mq_set_handle(shm_mq_handle *mqh, BackgroundWorkerHandle *handle)

void shm_mq_detach(shm_mq_handle *mqh)

void shm_mq_set_receiver(shm_mq *mq, PGPROC *proc)

shm_mq_handle * shm_mq_attach(shm_mq *mq, dsm_segment *seg, BackgroundWorkerHandle *handle)

void * shm_toc_allocate(shm_toc *toc, Size nbytes)

void shm_toc_insert(shm_toc *toc, uint64 key, void *address)

void * shm_toc_lookup(shm_toc *toc, uint64 key, bool noError)

#define shm_toc_estimate_chunk(e, sz)

#define shm_toc_estimate_keys(e, cnt)

Size add_size(Size s1, Size s2)

Size mul_size(Size s1, Size s2)

Snapshot GetActiveSnapshot(void)

List * es_part_prune_infos

struct dsa_area * es_query_dsa

struct JitContext * es_jit

PlannedStmt * es_plannedstmt

struct JitInstrumentation * es_jit_worker_instr

ParamExecData * es_param_exec_vals

Bitmapset * es_unpruned_relids

ParamListInfo es_param_list_info

MemoryContext es_query_cxt

const char * es_sourceText

SharedExecutorInstrumentation * instrumentation

shm_toc_estimator estimator

ParallelWorkerInfo * worker

struct SharedJitInstrumentation * jit_instrumentation

BufferUsage * buffer_usage

SharedExecutorInstrumentation * instrumentation

struct TupleQueueReader ** reader

BackgroundWorkerHandle * bgwhandle

struct SharedJitInstrumentation * worker_jit_instrument

Instrumentation * instrument

WorkerInstrumentation * worker_instrument

Bitmapset * rewindPlanIDs

PlannedStmtOrigin planOrigin

Bitmapset * unprunableRelids

PlannedStmt * plannedstmt

Instrumentation instrument[FLEXIBLE_ARRAY_MEMBER]

void(* rDestroy)(DestReceiver *self)

DestReceiver * CreateTupleQueueDestReceiver(shm_mq_handle *handle)

TupleQueueReader * CreateTupleQueueReader(shm_mq_handle *handle)

void DestroyTupleQueueReader(TupleQueueReader *reader)