PostgreSQL中AutoVacLauncherMain函数的实现逻辑是什么
本篇内容介绍了“PostgreSQL中AutoVacLauncherMain函数的实现逻辑是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
创新互联于2013年开始，是专业互联网技术服务公司，拥有项目网站设计、成都网站设计网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元大理州做网站,已为上家服务,为大理州各地企业和个人服务,联系电话:18982081108
一、数据结构
宏定义
#define GetProcessingMode() Mode
#define SetProcessingMode(mode) \
do { \
AssertArg((mode) == BootstrapProcessing || \
(mode) == InitProcessing || \
(mode) == NormalProcessing); \
Mode = (mode); \
} while(0)二、源码解读
AutoVacLauncherMain函数,autovacuum进程主循环.
/*
* Main loop for the autovacuum launcher process.
* autovacuum进程主循环
*/
NON_EXEC_STATIC void
AutoVacLauncherMain(int argc, char *argv[])
{
sigjmp_buf local_sigjmp_buf;
am_autovacuum_launcher = true;
/* Identify myself via ps */
//进程ID
init_ps_display(pgstat_get_backend_desc(B_AUTOVAC_LAUNCHER), "", "", "");
ereport(DEBUG1,
(errmsg("autovacuum launcher started")));
if (PostAuthDelay)
pg_usleep(PostAuthDelay * 1000000L);
//设置进程模式
SetProcessingMode(InitProcessing);
/*
* Set up signal handlers. We operate on databases much like a regular
* backend, so we use the same signal handling. See equivalent code in
* tcop/postgres.c.
* 设置信号控制器.
* autovacuum的执行类似于普通的后台进程,因此使用相同的信号控制机制.
* 参考tcop/postgres.c中的代码.
*/
pqsignal(SIGHUP, av_sighup_handler);
pqsignal(SIGINT, StatementCancelHandler);
pqsignal(SIGTERM, avl_sigterm_handler);
pqsignal(SIGQUIT, quickdie);
//建立SIGALRM控制器
InitializeTimeouts(); /* establishes SIGALRM handler */
pqsignal(SIGPIPE, SIG_IGN);//忽略SIGPIPE
pqsignal(SIGUSR1, procsignal_sigusr1_handler);
pqsignal(SIGUSR2, avl_sigusr2_handler);
pqsignal(SIGFPE, FloatExceptionHandler);
pqsignal(SIGCHLD, SIG_DFL);
/* Early initialization */
//基础初始化
BaseInit();
/*
* Create a per-backend PGPROC struct in shared memory, except in the
* EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
* this before we can use LWLocks (and in the EXEC_BACKEND case we already
* had to do some stuff with LWLocks).
* 在共享内存中创建每个后台进程的PGPROC结构体，
* 但除了exEXEC_BACKEND这种情况，这是在SubPostmasterMain中完成的。
*/
#ifndef EXEC_BACKEND
InitProcess();
#endif
//初始化
InitPostgres(NULL, InvalidOid, NULL, InvalidOid, NULL, false);
//设置进程模式
SetProcessingMode(NormalProcessing);
/*
* Create a memory context that we will do all our work in. We do this so
* that we can reset the context during error recovery and thereby avoid
* possible memory leaks.
* 创建内存上下文.
* 之所以这样做是因为我们可以在错误恢复中重置上下文,并且可以避免内存泄漏.
*/
AutovacMemCxt = AllocSetContextCreate(TopMemoryContext,
"Autovacuum Launcher",
ALLOCSET_DEFAULT_SIZES);
MemoryContextSwitchTo(AutovacMemCxt);
/*
* If an exception is encountered, processing resumes here.
* 如果出现异常,在这里重新恢复.
*
* This code is a stripped down version of PostgresMain error recovery.
* 这段代码是PostgresMain错误恢复的精简版。
*/
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* since not using PG_TRY, must reset error stack by hand */
//由于没有使用PG_TRY,这里必须手工重置错误.
error_context_stack = NULL;
/* Prevents interrupts while cleaning up */
//在清理期间禁用中断
HOLD_INTERRUPTS();
/* Forget any pending QueryCancel or timeout request */
//忽略所有QueryCancel或者超时请求
disable_all_timeouts(false);
QueryCancelPending = false; /* second to avoid race condition */
/* Report the error to the server log */
//在服务器日志中记录日志.
EmitErrorReport();
/* Abort the current transaction in order to recover */
//废弃当前事务,以准备恢复
AbortCurrentTransaction();
/*
* Release any other resources, for the case where we were not in a
* transaction.
* 释放任何其他资源，以防我们不在事务中。
*/
LWLockReleaseAll();
pgstat_report_wait_end();
AbortBufferIO();
UnlockBuffers();
/* this is probably dead code, but let's be safe: */
//这可能是dead code,但可以保证安全
if (AuxProcessResourceOwner)
ReleaseAuxProcessResources(false);
AtEOXact_Buffers(false);
AtEOXact_SMgr();
AtEOXact_Files(false);
AtEOXact_HashTables(false);
/*
* Now return to normal top-level context and clear ErrorContext for
* next time.
* 现在切换回正常的顶层上下文中,并为下一次的启动清理错误上下文
*/
MemoryContextSwitchTo(AutovacMemCxt);
FlushErrorState();
/* Flush any leaked data in the top-level context */
//在top-level上下文刷新所有泄漏的数据
MemoryContextResetAndDeleteChildren(AutovacMemCxt);
/* don't leave dangling pointers to freed memory */
//不要留下悬空指针来释放内存
DatabaseListCxt = NULL;
dlist_init(&DatabaseList);
/*
* Make sure pgstat also considers our stat data as gone. Note: we
* mustn't use autovac_refresh_stats here.
* 确保pgstat也认为我们的统计数据已经丢弃。
* 注意:这里不能使用autovac_refresh_stats。
*/
pgstat_clear_snapshot();
/* Now we can allow interrupts again */
//可以允许中断了
RESUME_INTERRUPTS();
/* if in shutdown mode, no need for anything further; just go away */
//如处于shutdown模式,不需要继续后续的工作了,跳转到shutdown
if (got_SIGTERM)
goto shutdown;
/*
* Sleep at least 1 second after any error. We don't want to be
* filling the error logs as fast as we can.
*/
pg_usleep(1000000L);
}
/* We can now handle ereport(ERROR) */
//现在可以处理ereport(ERROR)了
PG_exception_stack = &local_sigjmp_buf;
/* must unblock signals before calling rebuild_database_list */
//在调用rebuild_database_list前不能阻塞信号
PG_SETMASK(&UnBlockSig);
/*
* Set always-secure search path. Launcher doesn't connect to a database,
* so this has no effect.
* 设置安全的搜索路径.
* Launcher不能连接数据库,因此并没有什么影响.
*/
SetConfigOption("search_path", "", PGC_SUSET, PGC_S_OVERRIDE);
/*
* Force zero_damaged_pages OFF in the autovac process, even if it is set
* in postgresql.conf. We don't really want such a dangerous option being
* applied non-interactively.
* 在autovacuum进程中,强制关闭zero_damaged_pages,即时该参数在配置文件设置为ON.
* 我们真的不希望这样一个危险的选项在无需交互的情况进行应用.
*/
SetConfigOption("zero_damaged_pages", "false", PGC_SUSET, PGC_S_OVERRIDE);
/*
* Force settable timeouts off to avoid letting these settings prevent
* regular maintenance from being executed.
* 强制关闭可设置的超时，以避免这些设置妨碍常规维护的执行。
*/
SetConfigOption("statement_timeout", "0", PGC_SUSET, PGC_S_OVERRIDE);
SetConfigOption("lock_timeout", "0", PGC_SUSET, PGC_S_OVERRIDE);
SetConfigOption("idle_in_transaction_session_timeout", "0",
PGC_SUSET, PGC_S_OVERRIDE);
/*
* Force default_transaction_isolation to READ COMMITTED. We don't want
* to pay the overhead of serializable mode, nor add any risk of causing
* deadlocks or delaying other transactions.
* 强制default_transaction_isolation为READ COMMITTED.
* 我们不希望在serializable模式下增加负担,也不想增加导致死锁或者其他事务延迟的风险.
*/
SetConfigOption("default_transaction_isolation", "read committed",
PGC_SUSET, PGC_S_OVERRIDE);
/*
* In emergency mode, just start a worker (unless shutdown was requested)
* and go away.
* 在紧急模式,启动一个worker(除非已请求shutdown)
*/
if (!AutoVacuumingActive())
{
if (!got_SIGTERM)
do_start_worker();
proc_exit(0); /* done */
}
AutoVacuumShmem->av_launcherpid = MyProcPid;
/*
* Create the initial database list. The invariant we want this list to
* keep is that it's ordered by decreasing next_time. As soon as an entry
* is updated to a higher time, it will be moved to the front (which is
* correct because the only operation is to add autovacuum_naptime to the
* entry, and time always increases).
* 创建初始化数据库链表.
* 我们希望这个链表保持不变的是它是通过减少next_time来进行排序.
* 一旦条目更新到更高的时间，它就会被移动到前面
* (这样处理没有问题，因为惟一的操作是向条目添加autovacuum_naptime，而时间总是会增加)。
*/
rebuild_database_list(InvalidOid);
/* loop until shutdown request */
//循环,直至请求shutdown
while (!got_SIGTERM)
{
struct timeval nap;
TimestampTz current_time = 0;
bool can_launch;
/*
* This loop is a bit different from the normal use of WaitLatch,
* because we'd like to sleep before the first launch of a child
* process. So it's WaitLatch, then ResetLatch, then check for
* wakening conditions.
* 该循环与常规的使用WaitLatch不同,因为我们希望在第一个子进程启动前处于休眠状态.
* 因此首先是WaitLatch,然后是ResetLatch,然后检查并等待唤醒条件.
*/
launcher_determine_sleep(!dlist_is_empty(&AutoVacuumShmem->av_freeWorkers),
false, &nap);
/*
* Wait until naptime expires or we get some type of signal (all the
* signal handlers will wake us by calling SetLatch).
* 等待,直至naptime超时或者我们接收到某些类型的信号.
* (所有的信号控制器会通过调用SetLatch唤醒进程)
*/
(void) WaitLatch(MyLatch,
WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
(nap.tv_sec * 1000L) + (nap.tv_usec / 1000L),
WAIT_EVENT_AUTOVACUUM_MAIN);
ResetLatch(MyLatch);
/* Process sinval catchup interrupts that happened while sleeping */
//在休眠过程中,进程会捕获相关的中断.
ProcessCatchupInterrupt();
/* the normal shutdown case */
//shutdonw信号
if (got_SIGTERM)
break;
if (got_SIGHUP)
{
//SIGHUP信号
got_SIGHUP = false;
ProcessConfigFile(PGC_SIGHUP);
/* shutdown requested in config file? */
//在配置文件中已请求shutdown?
if (!AutoVacuumingActive())
break;
/* rebalance in case the default cost parameters changed */
//如默认的成本参数变化,则自动平衡.
LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
autovac_balance_cost();
LWLockRelease(AutovacuumLock);
/* rebuild the list in case the naptime changed */
//如naptime出现变化,重建链表
rebuild_database_list(InvalidOid);
}
/*
* a worker finished, or postmaster signalled failure to start a
* worker
* 某个worker已完成,或者postmaster信号出现异常无法启动worker
*/
if (got_SIGUSR2)
{
//SIGUSR2信号
got_SIGUSR2 = false;
/* rebalance cost limits, if needed */
//如需要,重平衡成本限制
if (AutoVacuumShmem->av_signal[AutoVacRebalance])
{
LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
AutoVacuumShmem->av_signal[AutoVacRebalance] = false;
autovac_balance_cost();
LWLockRelease(AutovacuumLock);
}
if (AutoVacuumShmem->av_signal[AutoVacForkFailed])
{
/*
* If the postmaster failed to start a new worker, we sleep
* for a little while and resend the signal. The new worker's
* state is still in memory, so this is sufficient. After
* that, we restart the main loop.
* 如果postmaster无法启动新的worker,休眠一段时间,重新发送信号.
* 新的worker的状态仍然在内存中,因此这样处理是OK的.
* 再次之后,重新启动主循环.
*
* XXX should we put a limit to the number of times we retry?
* I don't think it makes much sense, because a future start
* of a worker will continue to fail in the same way.
* 是否增加重试次数的限制?XXX
* 我们不想太过敏感,因为某个worker在未来的启动会以同样的方式持续失败.
*/
AutoVacuumShmem->av_signal[AutoVacForkFailed] = false;
pg_usleep(1000000L); /* 1s */
SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER);
continue;
}
}
/*
* There are some conditions that we need to check before trying to
* start a worker. First, we need to make sure that there is a worker
* slot available. Second, we need to make sure that no other worker
* failed while starting up.
* 在尝试启动worker前,有一些条件需要检查.
* 首先,需要确保有可用的worker slot;其次,需要确保worker在启动时没有出现异常.
*/
current_time = GetCurrentTimestamp();
LWLockAcquire(AutovacuumLock, LW_SHARED);
can_launch = !dlist_is_empty(&AutoVacuumShmem->av_freeWorkers);
if (AutoVacuumShmem->av_startingWorker != NULL)
{
int waittime;
WorkerInfo worker = AutoVacuumShmem->av_startingWorker;
/*
* We can't launch another worker when another one is still
* starting up (or failed while doing so), so just sleep for a bit
* more; that worker will wake us up again as soon as it's ready.
* We will only wait autovacuum_naptime seconds (up to a maximum
* of 60 seconds) for this to happen however. Note that failure
* to connect to a particular database is not a problem here,
* because the worker removes itself from the startingWorker
* pointer before trying to connect. Problems detected by the
* postmaster (like fork() failure) are also reported and handled
* differently. The only problems that may cause this code to
* fire are errors in the earlier sections of AutoVacWorkerMain,
* before the worker removes the WorkerInfo from the
* startingWorker pointer.
* 在某个worker仍然在启动时,不能启动新的worker,因此休眠一段时间;
* 另外一个worker在ready后会第一时间唤醒我们.
* 只需要等待autovacuum_naptime参数设置的时间(单位秒)(最大为60s).
* 注意,在这里不能够连接一个特定的数据库不存在任何问题,因为worker在
* 尝试连接时,通过startingWorker指针销毁自己.
* 通过postmaster检测到问题(如fork()失败)会报告并且进行不同的处理,
* 这里唯一的问题是可能导致这里的处理逻辑在AutoVacWorkerMain的早起触发错误,
* 而且实在worker通过startingWorker指针清除WorkerInfo前.
*/
waittime = Min(autovacuum_naptime, 60) * 1000;
if (TimestampDifferenceExceeds(worker->wi_launchtime, current_time,
waittime))
{
LWLockRelease(AutovacuumLock);
LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
/*
* No other process can put a worker in starting mode, so if
* startingWorker is still INVALID after exchanging our lock,
* we assume it's the same one we saw above (so we don't
* recheck the launch time).
*/
if (AutoVacuumShmem->av_startingWorker != NULL)
{
worker = AutoVacuumShmem->av_startingWorker;
worker->wi_dboid = InvalidOid;
worker->wi_tableoid = InvalidOid;
worker->wi_sharedrel = false;
worker->wi_proc = NULL;
worker->wi_launchtime = 0;
dlist_push_head(&AutoVacuumShmem->av_freeWorkers,
&worker->wi_links);
AutoVacuumShmem->av_startingWorker = NULL;
elog(WARNING, "worker took too long to start; canceled");
}
}
else
can_launch = false;
}
//释放锁
LWLockRelease(AutovacuumLock); /* either shared or exclusive */
/* if we can't do anything, just go back to sleep */
//什么都做不了,继续休眠
if (!can_launch)
continue;
/* We're OK to start a new worker */
//现在可以启动新的worker
if (dlist_is_empty(&DatabaseList))
{
/*
* Special case when the list is empty: start a worker right away.
* This covers the initial case, when no database is in pgstats
* (thus the list is empty). Note that the constraints in
* launcher_determine_sleep keep us from starting workers too
* quickly (at most once every autovacuum_naptime when the list is
* empty).
* 在链表为空时的特殊情况:正确的启动一个worker.
* 这涵盖了刚初始的情况，即pgstats中没有数据库(因此链表为空)。
* 请注意，launcher_determine_sleep中的约束使我们不能过快地启动worker
* (当链表为空时，最多一次autovacuum_naptime)。
*/
launch_worker(current_time);
}
else
{
/*
* because rebuild_database_list constructs a list with most
* distant adl_next_worker first, we obtain our database from the
* tail of the list.
* 因为rebuild_database_list首先用最远的adl_next_worker构造了链表，
* 所以我们从链表的尾部获取数据库。
*/
avl_dbase *avdb;
avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
/*
* launch a worker if next_worker is right now or it is in the
* past
* 启动worker,如果next_worker正当其时或者已成为过去时.
*/
if (TimestampDifferenceExceeds(avdb->adl_next_worker,
current_time, 0))
launch_worker(current_time);
}
}
/* Normal exit from the autovac launcher is here */
//常规的退出.
shutdown:
ereport(DEBUG1,
(errmsg("autovacuum launcher shutting down")));
AutoVacuumShmem->av_launcherpid = 0;
proc_exit(0); /* done */
}“PostgreSQL中AutoVacLauncherMain函数的实现逻辑是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！
本文标题：PostgreSQL中AutoVacLauncherMain函数的实现逻辑是什么
链接分享：http://6mz.cn/article/ghejid.html