database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-28 23:42:10 +03:00
Code Activity

code: replace 'master' with 'leader' where appropriate.

Browse Source 
Leader already is the more widely used terminology, but a few places
didn't get the message.

Author: Andres Freund
Reviewed-By: David Steele
Discussion: https://postgr.es/m/20200615182235.x7lch5n6kcjq4aue@alap3.anarazel.de
This commit is contained in:
Andres Freund
2020-06-14 14:22:47 -07:00
parent 5e7bbb5286
commit e07633646a
18 changed files with 120 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/backend/access/transam/parallel.c
View File

@ -89,9 +89,9 @@ typedef struct FixedParallelState
Oid temp_toast_namespace_id;
int sec_context;
bool is_superuser;
PGPROC *parallel_master_pgproc;
pid_t parallel_master_pid;
BackendId parallel_master_backend_id;
PGPROC *parallel_leader_pgproc;
pid_t parallel_leader_pid;
BackendId parallel_leader_backend_id;
TimestampTz xact_ts;
TimestampTz stmt_ts;
SerializableXactHandle serializable_xact_handle;
@ -124,7 +124,7 @@ static FixedParallelState *MyFixedParallelState;
static dlist_head pcxt_list = DLIST_STATIC_INIT(pcxt_list);
/* Backend-local copy of data from FixedParallelState. */
static pid_t ParallelMasterPid;
static pid_t ParallelLeaderPid;
/*
* List of internal parallel worker entry points. We need this for
@ -323,9 +323,9 @@ InitializeParallelDSM(ParallelContext *pcxt)
GetUserIdAndSecContext(&fps->current_user_id, &fps->sec_context);
GetTempNamespaceState(&fps->temp_namespace_id,
&fps->temp_toast_namespace_id);
fps->parallel_master_pgproc = MyProc;
fps->parallel_master_pid = MyProcPid;
fps->parallel_master_backend_id = MyBackendId;
fps->parallel_leader_pgproc = MyProc;
fps->parallel_leader_pid = MyProcPid;
fps->parallel_leader_backend_id = MyBackendId;
fps->xact_ts = GetCurrentTransactionStartTimestamp();
fps->stmt_ts = GetCurrentStatementStartTimestamp();
fps->serializable_xact_handle = ShareSerializableXact();
@ -857,8 +857,8 @@ WaitForParallelWorkersToFinish(ParallelContext *pcxt)
*
* This function ensures that workers have been completely shutdown. The
* difference between WaitForParallelWorkersToFinish and this function is
* that former just ensures that last message sent by worker backend is
* received by master backend whereas this ensures the complete shutdown.
* that the former just ensures that last message sent by a worker backend is
* received by the leader backend whereas this ensures the complete shutdown.
*/
static void
WaitForParallelWorkersToExit(ParallelContext *pcxt)
@ -1302,8 +1302,8 @@ ParallelWorkerMain(Datum main_arg)
MyFixedParallelState = fps;
/* Arrange to signal the leader if we exit. */
ParallelMasterPid = fps->parallel_master_pid;
ParallelMasterBackendId = fps->parallel_master_backend_id;
ParallelLeaderPid = fps->parallel_leader_pid;
ParallelLeaderBackendId = fps->parallel_leader_backend_id;
on_shmem_exit(ParallelWorkerShutdown, (Datum) 0);
/*
@ -1318,8 +1318,8 @@ ParallelWorkerMain(Datum main_arg)
shm_mq_set_sender(mq, MyProc);
mqh = shm_mq_attach(mq, seg, NULL);
pq_redirect_to_shm_mq(seg, mqh);
pq_set_parallel_master(fps->parallel_master_pid,
fps->parallel_master_backend_id);
pq_set_parallel_leader(fps->parallel_leader_pid,
fps->parallel_leader_backend_id);
/*
* Send a BackendKeyData message to the process that initiated parallelism
@ -1347,8 +1347,8 @@ ParallelWorkerMain(Datum main_arg)
* deadlock. (If we can't join the lock group, the leader has gone away,
* so just exit quietly.)
*/
if (!BecomeLockGroupMember(fps->parallel_master_pgproc,
fps->parallel_master_pid))
if (!BecomeLockGroupMember(fps->parallel_leader_pgproc,
fps->parallel_leader_pid))
return;
/*
@ -1410,7 +1410,7 @@ ParallelWorkerMain(Datum main_arg)
/* Restore transaction snapshot. */
tsnapspace = shm_toc_lookup(toc, PARALLEL_KEY_TRANSACTION_SNAPSHOT, false);
RestoreTransactionSnapshot(RestoreSnapshot(tsnapspace),
fps->parallel_master_pgproc);
fps->parallel_leader_pgproc);
/* Restore active snapshot. */
asnapspace = shm_toc_lookup(toc, PARALLEL_KEY_ACTIVE_SNAPSHOT, false);
@ -1510,9 +1510,9 @@ ParallelWorkerReportLastRecEnd(XLogRecPtr last_xlog_end)
static void
ParallelWorkerShutdown(int code, Datum arg)
{
SendProcSignal(ParallelMasterPid,
SendProcSignal(ParallelLeaderPid,
PROCSIG_PARALLEL_MESSAGE,
ParallelMasterBackendId);
ParallelLeaderBackendId);
}
/*

12
src/backend/access/transam/xact.c
View File

@ -750,7 +750,7 @@ GetCurrentCommandId(bool used)
{
/*
* Forbid setting currentCommandIdUsed in a parallel worker, because
* we have no provision for communicating this back to the master. We
* we have no provision for communicating this back to the leader. We
* could relax this restriction when currentCommandIdUsed was already
* true at the start of the parallel operation.
*/
@ -987,7 +987,7 @@ ExitParallelMode(void)
/*
* IsInParallelMode
*
* Are we in a parallel operation, as either the master or a worker? Check
* Are we in a parallel operation, as either the leader or a worker? Check
* this to prohibit operations that change backend-local state expected to
* match across all workers. Mere caches usually don't require such a
* restriction. State modified in a strict push/pop fashion, such as the
@ -2164,13 +2164,13 @@ CommitTransaction(void)
else
{
/*
* We must not mark our XID committed; the parallel master is
* We must not mark our XID committed; the parallel leader is
* responsible for that.
*/
latestXid = InvalidTransactionId;
/*
* Make sure the master will know about any WAL we wrote before it
* Make sure the leader will know about any WAL we wrote before it
* commits.
*/
ParallelWorkerReportLastRecEnd(XactLastRecEnd);
@ -2699,7 +2699,7 @@ AbortTransaction(void)
latestXid = InvalidTransactionId;
/*
* Since the parallel master won't get our value of XactLastRecEnd in
* Since the parallel leader won't get our value of XactLastRecEnd in
* this case, we nudge WAL-writer ourselves in this case. See related
* comments in RecordTransactionAbort for why this matters.
*/
@ -4488,7 +4488,7 @@ RollbackAndReleaseCurrentSubTransaction(void)
/*
* Unlike ReleaseCurrentSubTransaction(), this is nominally permitted
* during parallel operations. That's because we may be in the master,
* during parallel operations. That's because we may be in the leader,
* recovering from an error thrown while we were in parallel mode. We
* won't reach here in a worker, because BeginInternalSubTransaction()
* will have failed.

2
src/backend/executor/execGrouping.c
View File

@ -190,7 +190,7 @@ BuildTupleHashTableExt(PlanState *parent,
hashtable->cur_eq_func = NULL;
/*
* If parallelism is in use, even if the master backend is performing the
* If parallelism is in use, even if the leader backend is performing the
* scan itself, we don't want to create the hashtable exactly the same way
* in all workers. As hashtables are iterated over in keyspace-order,
* doing so in all processes in the same way is likely to lead to

18
src/backend/libpq/pqmq.c
View File

@ -23,8 +23,8 @@
static shm_mq_handle *pq_mq_handle;
static bool pq_mq_busy = false;
static pid_t pq_mq_parallel_master_pid = 0;
static pid_t pq_mq_parallel_master_backend_id = InvalidBackendId;
static pid_t pq_mq_parallel_leader_pid = 0;
static pid_t pq_mq_parallel_leader_backend_id = InvalidBackendId;
static void pq_cleanup_redirect_to_shm_mq(dsm_segment *seg, Datum arg);
static void mq_comm_reset(void);
@ -73,15 +73,15 @@ pq_cleanup_redirect_to_shm_mq(dsm_segment *seg, Datum arg)
}
/*
* Arrange to SendProcSignal() to the parallel master each time we transmit
* Arrange to SendProcSignal() to the parallel leader each time we transmit
* message data via the shm_mq.
*/
void
pq_set_parallel_master(pid_t pid, BackendId backend_id)
pq_set_parallel_leader(pid_t pid, BackendId backend_id)
{
Assert(PqCommMethods == &PqCommMqMethods);
pq_mq_parallel_master_pid = pid;
pq_mq_parallel_master_backend_id = backend_id;
pq_mq_parallel_leader_pid = pid;
pq_mq_parallel_leader_backend_id = backend_id;
}
static void
@ -160,10 +160,10 @@ mq_putmessage(char msgtype, const char *s, size_t len)
{
result = shm_mq_sendv(pq_mq_handle, iov, 2, true);
if (pq_mq_parallel_master_pid != 0)
SendProcSignal(pq_mq_parallel_master_pid,
if (pq_mq_parallel_leader_pid != 0)
SendProcSignal(pq_mq_parallel_leader_pid,
PROCSIG_PARALLEL_MESSAGE,
pq_mq_parallel_master_backend_id);
pq_mq_parallel_leader_backend_id);
if (result != SHM_MQ_WOULD_BLOCK)
break;

2
src/backend/optimizer/path/costsize.c
View File

@ -11,7 +11,7 @@
* cpu_tuple_cost Cost of typical CPU time to process a tuple
* cpu_index_tuple_cost Cost of typical CPU time to process an index tuple
* cpu_operator_cost Cost of CPU time to execute an operator or function
* parallel_tuple_cost Cost of CPU time to pass a tuple from worker to master backend
* parallel_tuple_cost Cost of CPU time to pass a tuple from worker to leader backend
* parallel_setup_cost Cost of setting up shared memory for parallelism
*
* We expect that the kernel will typically do some amount of read-ahead

4
src/backend/optimizer/util/clauses.c
View File

@ -1028,8 +1028,8 @@ max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context)
* We can't pass Params to workers at the moment either, so they are also
* parallel-restricted, unless they are PARAM_EXTERN Params or are
* PARAM_EXEC Params listed in safe_param_ids, meaning they could be
* either generated within the worker or can be computed in master and
* then their value can be passed to the worker.
* either generated within workers or can be computed by the leader and
* then their value can be passed to workers.
*/
else if (IsA(node, Param))
{

2
src/backend/utils/init/globals.c
View File

@ -80,7 +80,7 @@ char postgres_exec_path[MAXPGPATH]; /* full path to backend */
BackendId MyBackendId = InvalidBackendId;
BackendId ParallelMasterBackendId = InvalidBackendId;
BackendId ParallelLeaderBackendId = InvalidBackendId;
Oid MyDatabaseId = InvalidOid;

2
src/backend/utils/misc/guc.c
View File

@ -3448,7 +3448,7 @@ static struct config_real ConfigureNamesReal[] =
{
{"parallel_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
gettext_noop("Sets the planner's estimate of the cost of "
"passing each tuple (row) from worker to master backend."),
"passing each tuple (row) from worker to leader backend."),
NULL,
GUC_EXPLAIN
},

108
src/bin/pg_dump/parallel.c
View File

@ -16,20 +16,20 @@
/*
* Parallel operation works like this:
*
* The original, master process calls ParallelBackupStart(), which forks off
* The original, leader process calls ParallelBackupStart(), which forks off
* the desired number of worker processes, which each enter WaitForCommands().
*
* The master process dispatches an individual work item to one of the worker
* The leader process dispatches an individual work item to one of the worker
* processes in DispatchJobForTocEntry(). We send a command string such as
* "DUMP 1234" or "RESTORE 1234", where 1234 is the TocEntry ID.
* The worker process receives and decodes the command and passes it to the
* routine pointed to by AH->WorkerJobDumpPtr or AH->WorkerJobRestorePtr,
* which are routines of the current archive format. That routine performs
* the required action (dump or restore) and returns an integer status code.
* This is passed back to the master where we pass it to the
* This is passed back to the leader where we pass it to the
* ParallelCompletionPtr callback function that was passed to
* DispatchJobForTocEntry(). The callback function does state updating
* for the master control logic in pg_backup_archiver.c.
* for the leader control logic in pg_backup_archiver.c.
*
* In principle additional archive-format-specific information might be needed
* in commands or worker status responses, but so far that hasn't proved
@ -40,7 +40,7 @@
* threads in the same process. To avoid problems, they work with cloned
* copies of the Archive data structure; see RunWorker().)
*
* In the master process, the workerStatus field for each worker has one of
* In the leader process, the workerStatus field for each worker has one of
* the following values:
* WRKR_NOT_STARTED: we've not yet forked this worker
* WRKR_IDLE: it's waiting for a command
@ -88,8 +88,8 @@ typedef enum
/*
* Private per-parallel-worker state (typedef for this is in parallel.h).
*
* Much of this is valid only in the master process (or, on Windows, should
* be touched only by the master thread). But the AH field should be touched
* Much of this is valid only in the leader process (or, on Windows, should
* be touched only by the leader thread). But the AH field should be touched
* only by workers. The pipe descriptors are valid everywhere.
*/
struct ParallelSlot
@ -102,7 +102,7 @@ struct ParallelSlot
ArchiveHandle *AH; /* Archive data worker is using */
int pipeRead; /* master's end of the pipes */
int pipeRead; /* leader's end of the pipes */
int pipeWrite;
int pipeRevRead; /* child's end of the pipes */
int pipeRevWrite;
@ -124,7 +124,7 @@ struct ParallelSlot
*/
typedef struct
{
ArchiveHandle *AH; /* master database connection */
ArchiveHandle *AH; /* leader database connection */
ParallelSlot *slot; /* this worker's parallel slot */
} WorkerInfo;
@ -157,9 +157,9 @@ static ShutdownInformation shutdown_info;
* State info for signal handling.
* We assume signal_info initializes to zeroes.
*
* On Unix, myAH is the master DB connection in the master process, and the
* On Unix, myAH is the leader DB connection in the leader process, and the
* worker's own connection in worker processes. On Windows, we have only one
* instance of signal_info, so myAH is the master connection and the worker
* instance of signal_info, so myAH is the leader connection and the worker
* connections must be dug out of pstate->parallelSlot[].
*/
typedef struct DumpSignalInformation
@ -216,8 +216,8 @@ static void lockTableForWorker(ArchiveHandle *AH, TocEntry *te);
static void WaitForCommands(ArchiveHandle *AH, int pipefd[2]);
static bool ListenToWorkers(ArchiveHandle *AH, ParallelState *pstate,
bool do_wait);
static char *getMessageFromMaster(int pipefd[2]);
static void sendMessageToMaster(int pipefd[2], const char *str);
static char *getMessageFromLeader(int pipefd[2]);
static void sendMessageToLeader(int pipefd[2], const char *str);
static int select_loop(int maxFd, fd_set *workerset);
static char *getMessageFromWorker(ParallelState *pstate,
bool do_wait, int *worker);
@ -277,7 +277,7 @@ init_parallel_dump_utils(void)
/*
* Find the ParallelSlot for the current worker process or thread.
*
* Returns NULL if no matching slot is found (this implies we're the master).
* Returns NULL if no matching slot is found (this implies we're the leader).
*/
static ParallelSlot *
GetMyPSlot(ParallelState *pstate)
@ -367,7 +367,7 @@ archive_close_connection(int code, void *arg)
if (!slot)
{
/*
* We're the master. Forcibly shut down workers, then close our
* We're the leader. Forcibly shut down workers, then close our
* own database connection, if any.
*/
ShutdownWorkersHard(si->pstate);
@ -381,7 +381,7 @@ archive_close_connection(int code, void *arg)
* We're a worker. Shut down our own DB connection if any. On
* Windows, we also have to close our communication sockets, to
* emulate what will happen on Unix when the worker process exits.
* (Without this, if this is a premature exit, the master would
* (Without this, if this is a premature exit, the leader would
* fail to detect it because there would be no EOF condition on
* the other end of the pipe.)
*/
@ -396,7 +396,7 @@ archive_close_connection(int code, void *arg)
}
else
{
/* Non-parallel operation: just kill the master DB connection */
/* Non-parallel operation: just kill the leader DB connection */
if (si->AHX)
DisconnectDatabase(si->AHX);
}
@ -541,11 +541,11 @@ WaitForTerminatingWorkers(ParallelState *pstate)
*
* In parallel operation on Unix, each process is responsible for canceling
* its own connection (this must be so because nobody else has access to it).
* Furthermore, the master process should attempt to forward its signal to
* Furthermore, the leader process should attempt to forward its signal to
* each child. In simple manual use of pg_dump/pg_restore, forwarding isn't
* needed because typing control-C at the console would deliver SIGINT to
* every member of the terminal process group --- but in other scenarios it
* might be that only the master gets signaled.
* might be that only the leader gets signaled.
*
* On Windows, the cancel handler runs in a separate thread, because that's
* how SetConsoleCtrlHandler works. We make it stop worker threads, send
@ -576,8 +576,8 @@ sigTermHandler(SIGNAL_ARGS)
pqsignal(SIGQUIT, SIG_IGN);
/*
* If we're in the master, forward signal to all workers. (It seems best
* to do this before PQcancel; killing the master transaction will result
* If we're in the leader, forward signal to all workers. (It seems best
* to do this before PQcancel; killing the leader transaction will result
* in invalid-snapshot errors from active workers, which maybe we can
* quiet by killing workers first.) Ignore any errors.
*/
@ -601,7 +601,7 @@ sigTermHandler(SIGNAL_ARGS)
/*
* Report we're quitting, using nothing more complicated than write(2).
* When in parallel operation, only the master process should do this.
* When in parallel operation, only the leader process should do this.
*/
if (!signal_info.am_worker)
{
@ -665,7 +665,7 @@ consoleHandler(DWORD dwCtrlType)
* If in parallel mode, stop worker threads and send QueryCancel to
* their connected backends. The main point of stopping the worker
* threads is to keep them from reporting the query cancels as errors,
* which would clutter the user's screen. We needn't stop the master
* which would clutter the user's screen. We needn't stop the leader
* thread since it won't be doing much anyway. Do this before
* canceling the main transaction, else we might get invalid-snapshot
* errors reported before we can stop the workers. Ignore errors,
@ -693,7 +693,7 @@ consoleHandler(DWORD dwCtrlType)
}
/*
* Send QueryCancel to master connection, if enabled. Ignore errors,
* Send QueryCancel to leader connection, if enabled. Ignore errors,
* there's not much we can do about them anyway.
*/
if (signal_info.myAH != NULL && signal_info.myAH->connCancel != NULL)
@ -949,11 +949,11 @@ ParallelBackupStart(ArchiveHandle *AH)
shutdown_info.pstate = pstate;
/*
* Temporarily disable query cancellation on the master connection. This
* Temporarily disable query cancellation on the leader connection. This
* ensures that child processes won't inherit valid AH->connCancel
* settings and thus won't try to issue cancels against the master's
* settings and thus won't try to issue cancels against the leader's
* connection. No harm is done if we fail while it's disabled, because
* the master connection is idle at this point anyway.
* the leader connection is idle at this point anyway.
*/
set_archive_cancel_info(AH, NULL);
@ -977,7 +977,7 @@ ParallelBackupStart(ArchiveHandle *AH)
if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
fatal("could not create communication channels: %m");
/* master's ends of the pipes */
/* leader's ends of the pipes */
slot->pipeRead = pipeWM[PIPE_READ];
slot->pipeWrite = pipeMW[PIPE_WRITE];
/* child's ends of the pipes */
@ -1008,13 +1008,13 @@ ParallelBackupStart(ArchiveHandle *AH)
/* instruct signal handler that we're in a worker now */
signal_info.am_worker = true;
/* close read end of Worker -> Master */
/* close read end of Worker -> Leader */
closesocket(pipeWM[PIPE_READ]);
/* close write end of Master -> Worker */
/* close write end of Leader -> Worker */
closesocket(pipeMW[PIPE_WRITE]);
/*
* Close all inherited fds for communication of the master with
* Close all inherited fds for communication of the leader with
* previously-forked workers.
*/
for (j = 0; j < i; j++)
@ -1035,19 +1035,19 @@ ParallelBackupStart(ArchiveHandle *AH)
fatal("could not create worker process: %m");
}
/* In Master after successful fork */
/* In Leader after successful fork */
slot->pid = pid;
slot->workerStatus = WRKR_IDLE;
/* close read end of Master -> Worker */
/* close read end of Leader -> Worker */
closesocket(pipeMW[PIPE_READ]);
/* close write end of Worker -> Master */
/* close write end of Worker -> Leader */
closesocket(pipeWM[PIPE_WRITE]);
#endif /* WIN32 */
}
/*
* Having forked off the workers, disable SIGPIPE so that master isn't
* Having forked off the workers, disable SIGPIPE so that leader isn't
* killed if it tries to send a command to a dead worker. We don't want
* the workers to inherit this setting, though.
*/
@ -1056,7 +1056,7 @@ ParallelBackupStart(ArchiveHandle *AH)
#endif
/*
* Re-establish query cancellation on the master connection.
* Re-establish query cancellation on the leader connection.
*/
set_archive_cancel_info(AH, AH->connection);
@ -1162,12 +1162,12 @@ parseWorkerCommand(ArchiveHandle *AH, TocEntry **te, T_Action *act,
Assert(*te != NULL);
}
else
fatal("unrecognized command received from master: \"%s\"",
fatal("unrecognized command received from leader: \"%s\"",
msg);
}
/*
* buildWorkerResponse: format a response string to send to the master.
* buildWorkerResponse: format a response string to send to the leader.
*
* The string is built in the caller-supplied buffer of size buflen.
*/
@ -1299,16 +1299,16 @@ IsEveryWorkerIdle(ParallelState *pstate)
/*
* Acquire lock on a table to be dumped by a worker process.
*
* The master process is already holding an ACCESS SHARE lock. Ordinarily
* The leader process is already holding an ACCESS SHARE lock. Ordinarily
* it's no problem for a worker to get one too, but if anything else besides
* pg_dump is running, there's a possible deadlock:
*
* 1) Master dumps the schema and locks all tables in ACCESS SHARE mode.
* 1) Leader dumps the schema and locks all tables in ACCESS SHARE mode.
* 2) Another process requests an ACCESS EXCLUSIVE lock (which is not granted
* because the master holds a conflicting ACCESS SHARE lock).
* because the leader holds a conflicting ACCESS SHARE lock).
* 3) A worker process also requests an ACCESS SHARE lock to read the table.
* The worker is enqueued behind the ACCESS EXCLUSIVE lock request.
* 4) Now we have a deadlock, since the master is effectively waiting for
* 4) Now we have a deadlock, since the leader is effectively waiting for
* the worker. The server cannot detect that, however.
*
* To prevent an infinite wait, prior to touching a table in a worker, request
@ -1349,7 +1349,7 @@ lockTableForWorker(ArchiveHandle *AH, TocEntry *te)
/*
* WaitForCommands: main routine for a worker process.
*
* Read and execute commands from the master until we see EOF on the pipe.
* Read and execute commands from the leader until we see EOF on the pipe.
*/
static void
WaitForCommands(ArchiveHandle *AH, int pipefd[2])
@ -1362,7 +1362,7 @@ WaitForCommands(ArchiveHandle *AH, int pipefd[2])
for (;;)
{
if (!(command = getMessageFromMaster(pipefd)))
if (!(command = getMessageFromLeader(pipefd)))
{
/* EOF, so done */
return;
@ -1387,10 +1387,10 @@ WaitForCommands(ArchiveHandle *AH, int pipefd[2])
else
Assert(false);
/* Return status to master */
/* Return status to leader */
buildWorkerResponse(AH, te, act, status, buf, sizeof(buf));
sendMessageToMaster(pipefd, buf);
sendMessageToLeader(pipefd, buf);
/* command was pg_malloc'd and we are responsible for free()ing it. */
free(command);
@ -1464,7 +1464,7 @@ ListenToWorkers(ArchiveHandle *AH, ParallelState *pstate, bool do_wait)
* Any received results are passed to the callback specified to
* DispatchJobForTocEntry.
*
* This function is executed in the master process.
* This function is executed in the leader process.
*/
void
WaitForWorkers(ArchiveHandle *AH, ParallelState *pstate, WFW_WaitOption mode)
@ -1525,25 +1525,25 @@ WaitForWorkers(ArchiveHandle *AH, ParallelState *pstate, WFW_WaitOption mode)
}
/*
* Read one command message from the master, blocking if necessary
* Read one command message from the leader, blocking if necessary
* until one is available, and return it as a malloc'd string.
* On EOF, return NULL.
*
* This function is executed in worker processes.
*/
static char *
getMessageFromMaster(int pipefd[2])
getMessageFromLeader(int pipefd[2])
{
return readMessageFromPipe(pipefd[PIPE_READ]);
}
/*
* Send a status message to the master.
* Send a status message to the leader.
*
* This function is executed in worker processes.
*/
static void
sendMessageToMaster(int pipefd[2], const char *str)
sendMessageToLeader(int pipefd[2], const char *str)
{
int len = strlen(str) + 1;
@ -1592,7 +1592,7 @@ select_loop(int maxFd, fd_set *workerset)
* that's hard to distinguish from the no-data-available case, but for now
* our one caller is okay with that.
*
* This function is executed in the master process.
* This function is executed in the leader process.
*/
static char *
getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
@ -1657,7 +1657,7 @@ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
/*
* Send a command message to the specified worker process.
*
* This function is executed in the master process.
* This function is executed in the leader process.
*/
static void
sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
@ -1688,7 +1688,7 @@ readMessageFromPipe(int fd)
/*
* In theory, if we let piperead() read multiple bytes, it might give us
* back fragments of multiple messages. (That can't actually occur, since
* neither master nor workers send more than one message without waiting
* neither leader nor workers send more than one message without waiting
* for a reply, but we don't wish to assume that here.) For simplicity,
* read a byte at a time until we get the terminating '\0'. This method
* is a bit inefficient, but since this is only used for relatively short

2
src/bin/pg_dump/parallel.h
View File

@ -18,7 +18,7 @@
#include "pg_backup_archiver.h"
/* Function to call in master process on completion of a worker task */
/* Function to call in leader process on completion of a worker task */
typedef void (*ParallelCompletionPtr) (ArchiveHandle *AH,
TocEntry *te,
int status,

10
src/bin/pg_dump/pg_backup_archiver.c
View File

@ -662,7 +662,7 @@ RestoreArchive(Archive *AHX)
restore_toc_entries_parallel(AH, pstate, &pending_list);
ParallelBackupEnd(AH, pstate);
/* reconnect the master and see if we missed something */
/* reconnect the leader and see if we missed something */
restore_toc_entries_postfork(AH, &pending_list);
Assert(AH->connection != NULL);
}
@ -2393,7 +2393,7 @@ WriteDataChunks(ArchiveHandle *AH, ParallelState *pstate)
if (pstate && pstate->numWorkers > 1)
{
/*
* In parallel mode, this code runs in the master process. We
* In parallel mode, this code runs in the leader process. We
* construct an array of candidate TEs, then sort it into decreasing
* size order, then dispatch each TE to a data-transfer worker. By
* dumping larger tables first, we avoid getting into a situation
@ -2447,7 +2447,7 @@ WriteDataChunks(ArchiveHandle *AH, ParallelState *pstate)
/*
* Callback function that's invoked in the master process after a step has
* Callback function that's invoked in the leader process after a step has
* been parallel dumped.
*
* We don't need to do anything except check for worker failure.
@ -4437,7 +4437,7 @@ pop_next_work_item(ArchiveHandle *AH, ParallelReadyList *ready_list,
* this is run in the worker, i.e. in a thread (Windows) or a separate process
* (everything else). A worker process executes several such work items during
* a parallel backup or restore. Once we terminate here and report back that
* our work is finished, the master process will assign us a new work item.
* our work is finished, the leader process will assign us a new work item.
*/
int
parallel_restore(ArchiveHandle *AH, TocEntry *te)
@ -4457,7 +4457,7 @@ parallel_restore(ArchiveHandle *AH, TocEntry *te)
/*
* Callback function that's invoked in the master process after a step has
* Callback function that's invoked in the leader process after a step has
* been parallel restored.
*
* Update status and reduce the dependency count of any dependent items.

2
src/bin/pg_dump/pg_backup_directory.c
View File

@ -807,7 +807,7 @@ _Clone(ArchiveHandle *AH)
*/
/*
* We also don't copy the ParallelState pointer (pstate), only the master
* We also don't copy the ParallelState pointer (pstate), only the leader
* process ever writes to it.
*/
}

2
src/bin/pg_dump/pg_dump.c
View File

@ -1238,7 +1238,7 @@ static void
setupDumpWorker(Archive *AH)
{
/*
* We want to re-select all the same values the master connection is
* We want to re-select all the same values the leader connection is
* using. We'll have inherited directly-usable values in
* AH->sync_snapshot_id and AH->use_role, but we need to translate the
* inherited encoding value back to a string to pass to setup_connection.

6
src/include/catalog/pg_proc.h
View File

@ -157,10 +157,10 @@ typedef FormData_pg_proc *Form_pg_proc;
/*
* Symbolic values for proparallel column: these indicate whether a function
* can be safely be run in a parallel backend, during parallelism but
* necessarily in the master, or only in non-parallel mode.
* necessarily in the leader, or only in non-parallel mode.
*/
#define PROPARALLEL_SAFE 's' /* can run in worker or master */
#define PROPARALLEL_RESTRICTED 'r' /* can run in parallel master only */
#define PROPARALLEL_SAFE 's' /* can run in worker or leader */
#define PROPARALLEL_RESTRICTED 'r' /* can run in parallel leader only */
#define PROPARALLEL_UNSAFE 'u' /* banned while in parallel mode */
/*

2
src/include/libpq/pqmq.h
View File

@ -17,7 +17,7 @@
#include "storage/shm_mq.h"
extern void pq_redirect_to_shm_mq(dsm_segment *seg, shm_mq_handle *mqh);
extern void pq_set_parallel_master(pid_t pid, BackendId backend_id);
extern void pq_set_parallel_leader(pid_t pid, BackendId backend_id);
extern void pq_parse_errornotice(StringInfo str, ErrorData *edata);

4
src/include/storage/backendid.h
View File

@ -25,13 +25,13 @@ typedef int BackendId; /* unique currently active backend identifier */
extern PGDLLIMPORT BackendId MyBackendId; /* backend id of this backend */
/* backend id of our parallel session leader, or InvalidBackendId if none */
extern PGDLLIMPORT BackendId ParallelMasterBackendId;
extern PGDLLIMPORT BackendId ParallelLeaderBackendId;
/*
* The BackendId to use for our session's temp relations is normally our own,
* but parallel workers should use their leader's ID.
*/
#define BackendIdForTempRelations() \
(ParallelMasterBackendId == InvalidBackendId ? MyBackendId : ParallelMasterBackendId)
(ParallelLeaderBackendId == InvalidBackendId ? MyBackendId : ParallelLeaderBackendId)
#endif /* BACKENDID_H */