* pages from a relation that is in the process of being dropped.
*
* While prewarming, autoprewarm will use two workers. There's a
- * master worker that reads and sorts the list of blocks to be
+ * leader worker that reads and sorts the list of blocks to be
* prewarmed and then launches a per-database worker for each
* relevant database in turn. The former keeps running after the
* initial prewarm is complete to update the dump file periodically.
static void apw_load_buffers(void);
static int apw_dump_now(bool is_bgworker, bool dump_unlogged);
-static void apw_start_master_worker(void);
+static void apw_start_leader_worker(void);
static void apw_start_database_worker(void);
static bool apw_init_shmem(void);
static void apw_detach_shmem(int code, Datum arg);
/* Register autoprewarm worker, if enabled. */
if (autoprewarm)
- apw_start_master_worker();
+ apw_start_leader_worker();
}
/*
- * Main entry point for the master autoprewarm process. Per-database workers
+ * Main entry point for the leader autoprewarm process. Per-database workers
* have a separate entry point.
*/
void
errmsg("autoprewarm worker is already running under PID %lu",
(unsigned long) pid)));
- apw_start_master_worker();
+ apw_start_leader_worker();
PG_RETURN_VOID();
}
}
/*
- * Start autoprewarm master worker process.
+ * Start autoprewarm leader worker process.
*/
static void
-apw_start_master_worker(void)
+apw_start_leader_worker(void)
{
BackgroundWorker worker;
BackgroundWorkerHandle *handle;
worker.bgw_start_time = BgWorkerStart_ConsistentState;
strcpy(worker.bgw_library_name, "pg_prewarm");
strcpy(worker.bgw_function_name, "autoprewarm_main");
- strcpy(worker.bgw_name, "autoprewarm master");
- strcpy(worker.bgw_type, "autoprewarm master");
+ strcpy(worker.bgw_name, "autoprewarm leader");
+ strcpy(worker.bgw_type, "autoprewarm leader");
if (process_shared_preload_libraries_in_progress)
{
</para>
<para>
Requesting exclusive locks on database objects while running a parallel dump could
- cause the dump to fail. The reason is that the <application>pg_dump</application> master process
+ cause the dump to fail. The reason is that the <application>pg_dump</application> leader process
requests shared locks on the objects that the worker processes are going to dump later
in order to
make sure that nobody deletes them and makes them go away while the dump is running.
If another client then requests an exclusive lock on a table, that lock will not be
- granted but will be queued waiting for the shared lock of the master process to be
+ granted but will be queued waiting for the shared lock of the leader process to be
released. Consequently any other access to the table will not be granted either and
will queue after the exclusive lock request. This includes the worker process trying
to dump the table. Without any precautions this would be a classic deadlock situation.
for standbys. With this feature, database clients can ensure they see
the same data set even though they use different connections.
<command>pg_dump -j</command> uses multiple database connections; it
- connects to the database once with the master process and once again
+ connects to the database once with the leader process and once again
for each worker job. Without the synchronized snapshot feature, the
different worker jobs wouldn't be guaranteed to see the same data in
each connection, which could lead to an inconsistent backup.
</para>
<para>
If you want to run a parallel dump of a pre-9.2 server, you need to make sure that the
- database content doesn't change from between the time the master connects to the
+ database content doesn't change from between the time the leader connects to the
database until the last worker job has connected to the database. The easiest way to
do this is to halt any data modifying processes (DDL and DML) accessing the database
before starting the backup. You also need to specify the
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;
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
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();
*
* 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)
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);
/*
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
* 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;
/*
/* 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);
static void
ParallelWorkerShutdown(int code, Datum arg)
{
- SendProcSignal(ParallelMasterPid,
+ SendProcSignal(ParallelLeaderPid,
PROCSIG_PARALLEL_MESSAGE,
- ParallelMasterBackendId);
+ ParallelLeaderBackendId);
}
/*
{
/*
* 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.
*/
/*
* 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
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);
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.
*/
/*
* 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.
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
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);
}
/*
- * 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
{
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;
* 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
* 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))
{
BackendId MyBackendId = InvalidBackendId;
-BackendId ParallelMasterBackendId = InvalidBackendId;
+BackendId ParallelLeaderBackendId = InvalidBackendId;
Oid MyDatabaseId = InvalidOid;
{
{"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
},
/*
* 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
* 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
/*
* 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
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;
*/
typedef struct
{
- ArchiveHandle *AH; /* master database connection */
+ ArchiveHandle *AH; /* leader database connection */
ParallelSlot *slot; /* this worker's parallel slot */
} WorkerInfo;
* 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
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);
/*
* 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)
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);
* 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.)
*/
}
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);
}
*
* 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
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.
*/
/*
* 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)
{
* 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,
}
/*
- * 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)
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);
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 */
/* 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++)
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.
*/
#endif
/*
- * Re-establish query cancellation on the master connection.
+ * Re-establish query cancellation on the leader connection.
*/
set_archive_cancel_info(AH, AH->connection);
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.
*/
/*
* 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
/*
* 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])
for (;;)
{
- if (!(command = getMessageFromMaster(pipefd)))
+ if (!(command = getMessageFromLeader(pipefd)))
{
/* EOF, so done */
return;
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);
* 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)
}
/*
- * 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;
* 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)
/*
* 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)
/*
* 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
#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,
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);
}
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
/*
- * 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.
* 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)
/*
- * 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.
*/
/*
- * 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.
*/
}
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.
/*
* 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 */
/*
#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);
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 */
projects / users / rhaas / postgres.git / commitdiff