#include "storage/block.h"

Include dependency graph for autovacuum.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	IsAnyAutoVacuumProcess() (IsAutoVacuumLauncherProcess() \|\| IsAutoVacuumWorkerProcess())

Enumerations
enum	AutoVacuumWorkItemType { AVW_BRINSummarizeRange }

Functions
bool	AutoVacuumingActive (void)

bool	IsAutoVacuumLauncherProcess (void)

bool	IsAutoVacuumWorkerProcess (void)

void	autovac_init (void)

int	StartAutoVacLauncher (void)

int	StartAutoVacWorker (void)

void	AutoVacWorkerFailed (void)

void	AutoVacuumUpdateDelay (void)

void	AutoVacuumRequestWork (AutoVacuumWorkItemType type, Oid relationId, BlockNumber blkno)

Size	AutoVacuumShmemSize (void)

void	AutoVacuumShmemInit (void)

Variables
bool	autovacuum_start_daemon

int	autovacuum_max_workers

int	autovacuum_work_mem

int	autovacuum_naptime

int	autovacuum_vac_thresh

double	autovacuum_vac_scale

int	autovacuum_anl_thresh

double	autovacuum_anl_scale

int	autovacuum_freeze_max_age

int	autovacuum_multixact_freeze_max_age

int	autovacuum_vac_cost_delay

int	autovacuum_vac_cost_limit

int	AutovacuumLauncherPid

int	Log_autovacuum_min_duration

Macro Definition Documentation

#define IsAnyAutoVacuumProcess ( ) (IsAutoVacuumLauncherProcess() || IsAutoVacuumWorkerProcess())

Definition at line 53 of file autovacuum.h.

Referenced by InitProcess().

Enumeration Type Documentation

enum AutoVacuumWorkItemType

Enumerator
AVW_BRINSummarizeRange

Definition at line 23 of file autovacuum.h.

 {
     AVW_BRINSummarizeRange
 } AutoVacuumWorkItemType;

Function Documentation

void autovac_init ( void )

Definition at line 3340 of file autovacuum.c.

References autovacuum_start_daemon, ereport, errhint(), errmsg(), pgstat_track_counts, and WARNING.

Referenced by PostmasterMain().

 {
     if (autovacuum_start_daemon && !pgstat_track_counts)
         ereport(WARNING,
                 (errmsg("autovacuum not started because of misconfiguration"),
                  errhint("Enable the \"track_counts\" option.")));
 }

bool AutoVacuumingActive ( void )

Definition at line 3219 of file autovacuum.c.

References autovacuum_start_daemon, and pgstat_track_counts.

Referenced by AutoVacLauncherMain(), reaper(), relation_needs_vacanalyze(), and ServerLoop().

 {
     if (!autovacuum_start_daemon || !pgstat_track_counts)
         return false;
     return true;
 }

void AutoVacuumRequestWork	(	AutoVacuumWorkItemType	type,
		Oid	relationId,
		BlockNumber	blkno
	)

Definition at line 3230 of file autovacuum.c.

References add_wi_to_list(), AutoVacuumShmemStruct::av_dsa_handle, AutoVacuumShmemStruct::av_workitems, AutovacWorkItems::avs_freeItems, AutovacWorkItems::avs_usedItems, AutoVacuumWorkItem::avw_active, AutoVacuumWorkItem::avw_blockNumber, AutoVacuumWorkItem::avw_database, AutoVacuumWorkItem::avw_next, AutoVacuumWorkItem::avw_relation, AutoVacuumWorkItem::avw_type, DSA_ALLOC_NO_OOM, dsa_allocate_extended(), dsa_attach(), dsa_detach(), dsa_get_address(), dsa_pin_mapping(), i, InvalidDsaPointer, InvalidOid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyDatabaseId, NULL, NUM_WORKITEMS, and remove_wi_from_list().

Referenced by brininsert().

 {
     AutovacWorkItems *workitems;
     dsa_pointer wi_ptr;
     AutoVacuumWorkItem *workitem;
 
     LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
 
     /*
      * It may be useful to de-duplicate the list upon insertion.  For the only
      * currently existing caller, this is not necessary.
      */
 
     /* First use in this process?  Set up DSA */
     if (!AutoVacuumDSA)
     {
         if (!AutoVacuumShmem->av_dsa_handle)
         {
             /* autovacuum launcher not started; nothing can be done */
             LWLockRelease(AutovacuumLock);
             return;
         }
         AutoVacuumDSA = dsa_attach(AutoVacuumShmem->av_dsa_handle);
         dsa_pin_mapping(AutoVacuumDSA);
     }
 
     /* First use overall?  Allocate work items array */
     if (AutoVacuumShmem->av_workitems == InvalidDsaPointer)
     {
         int         i;
         AutovacWorkItems *workitems;
 
         AutoVacuumShmem->av_workitems =
             dsa_allocate_extended(AutoVacuumDSA,
                                   sizeof(AutovacWorkItems) +
                                   NUM_WORKITEMS * sizeof(AutoVacuumWorkItem),
                                   DSA_ALLOC_NO_OOM);
         /* if out of memory, silently disregard the request */
         if (AutoVacuumShmem->av_workitems == InvalidDsaPointer)
         {
             LWLockRelease(AutovacuumLock);
             dsa_detach(AutoVacuumDSA);
             AutoVacuumDSA = NULL;
             return;
         }
 
         /* Initialize each array entry as a member of the free list */
         workitems = dsa_get_address(AutoVacuumDSA, AutoVacuumShmem->av_workitems);
 
         workitems->avs_usedItems = InvalidDsaPointer;
         workitems->avs_freeItems = InvalidDsaPointer;
         for (i = 0; i < NUM_WORKITEMS; i++)
         {
             /* XXX surely there is a simpler way to do this */
             wi_ptr = AutoVacuumShmem->av_workitems + sizeof(AutovacWorkItems) +
                 sizeof(AutoVacuumWorkItem) * i;
             workitem = (AutoVacuumWorkItem *) dsa_get_address(AutoVacuumDSA, wi_ptr);
 
             workitem->avw_type = 0;
             workitem->avw_database = InvalidOid;
             workitem->avw_relation = InvalidOid;
             workitem->avw_active = false;
 
             /* put this item in the free list */
             workitem->avw_next = workitems->avs_freeItems;
             workitems->avs_freeItems = wi_ptr;
         }
     }
 
     workitems = (AutovacWorkItems *)
         dsa_get_address(AutoVacuumDSA, AutoVacuumShmem->av_workitems);
 
     /* If array is full, disregard the request */
     if (workitems->avs_freeItems == InvalidDsaPointer)
     {
         LWLockRelease(AutovacuumLock);
         dsa_detach(AutoVacuumDSA);
         AutoVacuumDSA = NULL;
         return;
     }
 
     /* remove workitem struct from free list ... */
     wi_ptr = workitems->avs_freeItems;
     remove_wi_from_list(&workitems->avs_freeItems, wi_ptr);
 
     /* ... initialize it ... */
     workitem = dsa_get_address(AutoVacuumDSA, wi_ptr);
     workitem->avw_type = type;
     workitem->avw_database = MyDatabaseId;
     workitem->avw_relation = relationId;
     workitem->avw_blockNumber = blkno;
     workitem->avw_active = false;
 
     /* ... and put it on autovacuum's to-do list */
     add_wi_to_list(&workitems->avs_usedItems, wi_ptr);
 
     LWLockRelease(AutovacuumLock);
 
     dsa_detach(AutoVacuumDSA);
     AutoVacuumDSA = NULL;
 }

void AutoVacuumShmemInit ( void )

Definition at line 3390 of file autovacuum.c.

References Assert, autovacuum_max_workers, AutoVacuumShmemSize(), AutoVacuumShmemStruct::av_freeWorkers, AutoVacuumShmemStruct::av_launcherpid, AutoVacuumShmemStruct::av_runningWorkers, AutoVacuumShmemStruct::av_startingWorker, dlist_init(), dlist_push_head(), i, IsUnderPostmaster, MAXALIGN, NULL, ShmemInitStruct(), and WorkerInfoData::wi_links.

Referenced by CreateSharedMemoryAndSemaphores().

 {
     bool        found;
 
     AutoVacuumShmem = (AutoVacuumShmemStruct *)
         ShmemInitStruct("AutoVacuum Data",
                         AutoVacuumShmemSize(),
                         &found);
 
     if (!IsUnderPostmaster)
     {
         WorkerInfo  worker;
         int         i;
 
         Assert(!found);
 
         AutoVacuumShmem->av_launcherpid = 0;
         dlist_init(&AutoVacuumShmem->av_freeWorkers);
         dlist_init(&AutoVacuumShmem->av_runningWorkers);
         AutoVacuumShmem->av_startingWorker = NULL;
 
         worker = (WorkerInfo) ((char *) AutoVacuumShmem +
                                MAXALIGN(sizeof(AutoVacuumShmemStruct)));
 
         /* initialize the WorkerInfo free list */
         for (i = 0; i < autovacuum_max_workers; i++)
             dlist_push_head(&AutoVacuumShmem->av_freeWorkers,
                             &worker[i].wi_links);
     }
     else
         Assert(found);
 }

Size AutoVacuumShmemSize ( void )

Definition at line 3371 of file autovacuum.c.

References add_size(), autovacuum_max_workers, MAXALIGN, and mul_size().

Referenced by AutoVacuumShmemInit(), and CreateSharedMemoryAndSemaphores().

 {
     Size        size;
 
     /*
      * Need the fixed struct and the array of WorkerInfoData.
      */
     size = sizeof(AutoVacuumShmemStruct);
     size = MAXALIGN(size);
     size = add_size(size, mul_size(autovacuum_max_workers,
                                    sizeof(WorkerInfoData)));
     return size;
 }

void AutoVacuumUpdateDelay ( void )

Definition at line 1779 of file autovacuum.c.

References VacuumCostDelay, VacuumCostLimit, WorkerInfoData::wi_cost_delay, and WorkerInfoData::wi_cost_limit.

Referenced by do_autovacuum(), and vacuum_delay_point().

 {
     if (MyWorkerInfo)
     {
         VacuumCostDelay = MyWorkerInfo->wi_cost_delay;
         VacuumCostLimit = MyWorkerInfo->wi_cost_limit;
     }
 }

void AutoVacWorkerFailed ( void )

Definition at line 1404 of file autovacuum.c.

References AutoVacForkFailed, and AutoVacuumShmemStruct::av_signal.

Referenced by StartAutovacuumWorker().

 {
     AutoVacuumShmem->av_signal[AutoVacForkFailed] = true;
 }

bool IsAutoVacuumLauncherProcess ( void )

Definition at line 3354 of file autovacuum.c.

References am_autovacuum_launcher.

Referenced by autovac_refresh_stats(), backend_read_statsfile(), InitPostgres(), InitProcess(), pgstat_bestart(), and ProcKill().

 {
     return am_autovacuum_launcher;
 }

bool IsAutoVacuumWorkerProcess ( void )

Definition at line 3360 of file autovacuum.c.

References am_autovacuum_worker.

Referenced by analyze_rel(), backend_read_statsfile(), BuildRelationExtStatistics(), CheckMyDatabase(), do_analyze_rel(), ginbulkdelete(), ginInsertCleanup(), ginvacuumcleanup(), InitializeSessionUserIdStandalone(), InitPostgres(), InitProcess(), lazy_space_alloc(), lazy_vacuum_rel(), pgstat_bestart(), pgstat_report_analyze(), pgstat_report_vacuum(), proc_exit(), ProcessInterrupts(), vacuum(), and vacuum_rel().

 {
     return am_autovacuum_worker;
 }

int StartAutoVacLauncher ( void )

Definition at line 404 of file autovacuum.c.

References AutoVacLauncherMain(), AutoVacPID, ClosePostmasterPorts(), ereport, errmsg(), fork_process(), InitPostmasterChild(), LOG, and NULL.

Referenced by reaper(), and ServerLoop().

 {
     pid_t       AutoVacPID;
 
 #ifdef EXEC_BACKEND
     switch ((AutoVacPID = avlauncher_forkexec()))
 #else
     switch ((AutoVacPID = fork_process()))
 #endif
     {
         case -1:
             ereport(LOG,
                  (errmsg("could not fork autovacuum launcher process: %m")));
             return 0;
 
 #ifndef EXEC_BACKEND
         case 0:
             /* in postmaster child ... */
             InitPostmasterChild();
 
             /* Close the postmaster's sockets */
             ClosePostmasterPorts(false);
 
             AutoVacLauncherMain(0, NULL);
             break;
 #endif
         default:
             return (int) AutoVacPID;
     }
 
     /* shouldn't get here */
     return 0;
 }

int StartAutoVacWorker ( void )

Definition at line 1488 of file autovacuum.c.

References AutoVacWorkerMain(), ClosePostmasterPorts(), ereport, errmsg(), fork_process(), InitPostmasterChild(), LOG, and NULL.

Referenced by StartAutovacuumWorker().

 {
     pid_t       worker_pid;
 
 #ifdef EXEC_BACKEND
     switch ((worker_pid = avworker_forkexec()))
 #else
     switch ((worker_pid = fork_process()))
 #endif
     {
         case -1:
             ereport(LOG,
                     (errmsg("could not fork autovacuum worker process: %m")));
             return 0;
 
 #ifndef EXEC_BACKEND
         case 0:
             /* in postmaster child ... */
             InitPostmasterChild();
 
             /* Close the postmaster's sockets */
             ClosePostmasterPorts(false);
 
             AutoVacWorkerMain(0, NULL);
             break;
 #endif
         default:
             return (int) worker_pid;
     }
 
     /* shouldn't get here */
     return 0;
 }