step1-permanent_process.diff

*** src/backend/access/transam/varsup.c	58aea89cb33fe0ee2cb3e10c0a714cd0057a8bdb
--- src/backend/access/transam/varsup.c	058cb2f268e956e37724f1d05d98946d1cc56ab4
*************** GetNewTransactionId(bool isSubXact)
*** 46,51 ****
--- 46,52 ----
  GetNewTransactionId(bool isSubXact)
  {
  	TransactionId xid;
+ 	IMessage *msg;
  
  	/*
  	 * During bootstrap initialization, we return the special bootstrap
*************** GetNewTransactionId(bool isSubXact)
*** 94,105 ****
  		LWLockRelease(XidGenLock);
  
  		/*
! 		 * To avoid swamping the postmaster with signals, we issue the autovac
  		 * request only once per 64K transaction starts.  This still gives
  		 * plenty of chances before we get into real trouble.
  		 */
  		if (IsUnderPostmaster && (xid % 65536) == 0)
! 			SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
  
  		if (IsUnderPostmaster &&
  			TransactionIdFollowsOrEquals(xid, xidStopLimit))
--- 95,109 ----
  		LWLockRelease(XidGenLock);
  
  		/*
! 		 * To avoid swamping the coordinator with signals, we issue the autovac
  		 * request only once per 64K transaction starts.  This still gives
  		 * plenty of chances before we get into real trouble.
  		 */
  		if (IsUnderPostmaster && (xid % 65536) == 0)
! 		{
! 			msg = IMessageCreate(IMSGT_FORCE_VACUUM, 0);
! 			IMessageActivate(msg, GetAutovacuumLauncherId());
! 		}
  
  		if (IsUnderPostmaster &&
  			TransactionIdFollowsOrEquals(xid, xidStopLimit))
*************** SetTransactionIdLimit(TransactionId olde
*** 258,263 ****
--- 262,268 ----
  	TransactionId xidStopLimit;
  	TransactionId xidWrapLimit;
  	TransactionId curXid;
+ 	IMessage *msg;
  
  	Assert(TransactionIdIsNormal(oldest_datfrozenxid));
  
*************** SetTransactionIdLimit(TransactionId olde
*** 341,347 ****
  	 */
  	if (TransactionIdFollowsOrEquals(curXid, xidVacLimit) &&
  		IsUnderPostmaster && !InRecovery)
! 		SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
  
  	/* Give an immediate warning if past the wrap warn point */
  	if (TransactionIdFollowsOrEquals(curXid, xidWarnLimit) && !InRecovery)
--- 346,355 ----
  	 */
  	if (TransactionIdFollowsOrEquals(curXid, xidVacLimit) &&
  		IsUnderPostmaster && !InRecovery)
! 	{
! 		msg = IMessageCreate(IMSGT_FORCE_VACUUM, 0);
! 		IMessageActivate(msg, GetAutovacuumLauncherId());
! 	}
  
  	/* Give an immediate warning if past the wrap warn point */
  	if (TransactionIdFollowsOrEquals(curXid, xidWarnLimit) && !InRecovery)
============================================================
*** src/backend/postmaster/postmaster.c	13da26f5fb9a09c47a8dc3b30f0bbfdb1da0420c
--- src/backend/postmaster/postmaster.c	e6a455be46eee967cafa76cef125cedef4ba986f
*************** bool		redirection_done = false;	/* stder
*** 294,301 ****
  
  bool		redirection_done = false;	/* stderr redirected for syslogger? */
  
- /* received START_AUTOVAC_LAUNCHER signal */
- static volatile sig_atomic_t start_autovac_launcher = false;
  
  /* the launcher needs to be signalled to communicate some condition */
  static volatile bool avlauncher_needs_signal = false;
--- 294,299 ----
*************** ServerLoop(void)
*** 1463,1476 ****
  			WalWriterPID = StartWalWriter();
  
  		/* If we have lost the autovacuum launcher, try to start a new one */
! 		if (AutoVacPID == 0 &&
! 			(AutoVacuumingActive() || start_autovac_launcher) &&
! 			pmState == PM_RUN)
! 		{
  			AutoVacPID = StartAutoVacLauncher();
- 			if (AutoVacPID != 0)
- 				start_autovac_launcher = false; /* signal processed */
- 		}
  
  		/* If we have lost the archiver, try to start a new one */
  		if (XLogArchivingActive() && PgArchPID == 0 && pmState == PM_RUN)
--- 1461,1468 ----
  			WalWriterPID = StartWalWriter();
  
  		/* If we have lost the autovacuum launcher, try to start a new one */
! 		if (AutoVacPID == 0 && pmState == PM_RUN)
  			AutoVacPID = StartAutoVacLauncher();
  
  		/* If we have lost the archiver, try to start a new one */
  		if (XLogArchivingActive() && PgArchPID == 0 && pmState == PM_RUN)
*************** reaper(SIGNAL_ARGS)
*** 2390,2396 ****
  			 */
  			if (WalWriterPID == 0)
  				WalWriterPID = StartWalWriter();
! 			if (AutoVacuumingActive() && AutoVacPID == 0)
  				AutoVacPID = StartAutoVacLauncher();
  			if (XLogArchivingActive() && PgArchPID == 0)
  				PgArchPID = pgarch_start();
--- 2382,2388 ----
  			 */
  			if (WalWriterPID == 0)
  				WalWriterPID = StartWalWriter();
! 			if (AutoVacPID == 0)
  				AutoVacPID = StartAutoVacLauncher();
  			if (XLogArchivingActive() && PgArchPID == 0)
  				PgArchPID = pgarch_start();
*************** sigusr1_handler(SIGNAL_ARGS)
*** 4198,4217 ****
  		signal_child(SysLoggerPID, SIGUSR1);
  	}
  
- 	if (CheckPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER))
- 	{
- 		/*
- 		 * Start one iteration of the autovacuum daemon, even if autovacuuming
- 		 * is nominally not enabled.  This is so we can have an active defense
- 		 * against transaction ID wraparound.  We set a flag for the main loop
- 		 * to do it rather than trying to do it here --- this is because the
- 		 * autovac process itself may send the signal, and we want to handle
- 		 * that by launching another iteration as soon as the current one
- 		 * completes.
- 		 */
- 		start_autovac_launcher = true;
- 	}
- 
  	if (CheckPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER))
  	{
  		/* The autovacuum launcher wants us to start a worker process. */
--- 4190,4195 ----
*************** StartAutovacuumWorker(void)
*** 4518,4536 ****
  	}
  
  	/*
! 	 * Report the failure to the launcher, if it's running.  (If it's not, we
! 	 * might not even be connected to shared memory, so don't try to call
! 	 * AutoVacWorkerFailed.)  Note that we also need to signal it so that it
! 	 * responds to the condition, but we don't do that here, instead waiting
! 	 * for ServerLoop to do it.  This way we avoid a ping-pong signalling in
! 	 * quick succession between the autovac launcher and postmaster in case
! 	 * things get ugly.
  	 */
  	if (AutoVacPID != 0)
- 	{
- 		AutoVacWorkerFailed();
  		avlauncher_needs_signal = true;
- 	}
  }
  
  /*
--- 4496,4508 ----
  	}
  
  	/*
! 	 * Report the failure to the coordinator, if it's running. Note that we
! 	 * wait for the ServerLoop to actually trigger the signal. This way we
! 	 * avoid a ping-pong signalling in quick succession between coordinator
! 	 * and postmaster in case things get ugly.
  	 */
  	if (AutoVacPID != 0)
  		avlauncher_needs_signal = true;
  }
  
  /*
============================================================
*** src/backend/storage/lmgr/proc.c	410c53ed63ba8902d9747e9ad91a639e21195411
--- src/backend/storage/lmgr/proc.c	bbd84c0cdc85587bd4e04f1b69ead6ea11bb08dd
*************** InitProcess(void)
*** 263,276 ****
  
  	set_spins_per_delay(procglobal->spins_per_delay);
  
! 	if (IsAnyAutoVacuumProcess())
  		MyProc = procglobal->autovacFreeProcs;
  	else
  		MyProc = procglobal->freeProcs;
  
  	if (MyProc != NULL)
  	{
! 		if (IsAnyAutoVacuumProcess())
  			procglobal->autovacFreeProcs = (PGPROC *) MyProc->links.next;
  		else
  			procglobal->freeProcs = (PGPROC *) MyProc->links.next;
--- 263,276 ----
  
  	set_spins_per_delay(procglobal->spins_per_delay);
  
! 	if (IsAutoVacuumLauncherProcess() || IsAutoVacuumWorkerProcess())
  		MyProc = procglobal->autovacFreeProcs;
  	else
  		MyProc = procglobal->freeProcs;
  
  	if (MyProc != NULL)
  	{
! 		if (IsAutoVacuumLauncherProcess() || IsAutoVacuumWorkerProcess())
  			procglobal->autovacFreeProcs = (PGPROC *) MyProc->links.next;
  		else
  			procglobal->freeProcs = (PGPROC *) MyProc->links.next;
*************** ProcKill(int code, Datum arg)
*** 682,688 ****
  	SpinLockAcquire(ProcStructLock);
  
  	/* Return PGPROC structure (and semaphore) to appropriate freelist */
! 	if (IsAnyAutoVacuumProcess())
  	{
  		MyProc->links.next = (SHM_QUEUE *) procglobal->autovacFreeProcs;
  		procglobal->autovacFreeProcs = MyProc;
--- 682,688 ----
  	SpinLockAcquire(ProcStructLock);
  
  	/* Return PGPROC structure (and semaphore) to appropriate freelist */
! 	if (IsAutoVacuumLauncherProcess() || IsAutoVacuumWorkerProcess())
  	{
  		MyProc->links.next = (SHM_QUEUE *) procglobal->autovacFreeProcs;
  		procglobal->autovacFreeProcs = MyProc;
*************** ProcKill(int code, Datum arg)
*** 708,717 ****
  	 */
  	if (IsUnderPostmaster && !IsAutoVacuumLauncherProcess())
  		MarkPostmasterChildInactive();
- 
- 	/* wake autovac launcher if needed -- see comments in FreeWorkerInfo */
- 	if (AutovacuumLauncherPid != 0)
- 		kill(AutovacuumLauncherPid, SIGUSR2);
  }
  
  /*
--- 708,713 ----
============================================================
*** src/backend/utils/misc/guc.c	0d02c70862077335d5f009dc9f295b2dc7071c52
--- src/backend/utils/misc/guc.c	b1a0bdd9b727094182159680278763a09f3ded9c
*************** static struct config_bool ConfigureNames
*** 935,944 ****
  
  	{
  		{"autovacuum", PGC_SIGHUP, AUTOVACUUM,
! 			gettext_noop("Starts the autovacuum subprocess."),
  			NULL
  		},
! 		&autovacuum_start_daemon,
  		true, NULL, NULL
  	},
  
--- 935,944 ----
  
  	{
  		{"autovacuum", PGC_SIGHUP, AUTOVACUUM,
! 			gettext_noop("Enable automatic vacuuming."),
  			NULL
  		},
! 		&autovacuum_enabled,
  		true, NULL, NULL
  	},
  
*************** static struct config_int ConfigureNamesI
*** 1941,1946 ****
--- 1941,1963 ----
  	},
  
  	{
+ 		{"min_spare_background_workers", PGC_POSTMASTER, AUTOVACUUM,
+ 			gettext_noop("Sets the maximum number of simultaneously running autovacuum worker processes."),
+ 			NULL
+ 		},
+ 		&min_spare_background_workers,
+ 		0, 0, INT_MAX / 4, NULL, NULL
+ 	},
+ 	{
+ 		{"max_spare_background_workers", PGC_POSTMASTER, AUTOVACUUM,
+ 			gettext_noop("Sets the maximum number of simultaneously running autovacuum worker processes."),
+ 			NULL
+ 		},
+ 		&max_spare_background_workers,
+ 		0, 0, INT_MAX / 4, NULL, NULL
+ 	},
+ 
+ 	{
  		{"autovacuum_naptime", PGC_SIGHUP, AUTOVACUUM,
  			gettext_noop("Time to sleep between autovacuum runs."),
  			NULL,
============================================================
*** src/backend/utils/misc/postgresql.conf.sample	3b137fa18da4ec43ae76dc954fd19449556fbdce
--- src/backend/utils/misc/postgresql.conf.sample	14a99f6b70482f481ccd82dad86e31a9421c9336
***************
*** 404,419 ****
  
  
  #------------------------------------------------------------------------------
  # AUTOVACUUM PARAMETERS
  #------------------------------------------------------------------------------
  
! #autovacuum = on			# Enable autovacuum subprocess?  'on' 
! 					# requires track_counts to also be on.
  #log_autovacuum_min_duration = -1	# -1 disables, 0 logs all actions and
  					# their durations, > 0 logs only
  					# actions running at least this number
  					# of milliseconds.
- #autovacuum_max_workers = 3		# max number of autovacuum subprocesses
  #autovacuum_naptime = 1min		# time between autovacuum runs
  #autovacuum_vacuum_threshold = 50	# min number of row updates before
  					# vacuum
--- 404,431 ----
  
  
  #------------------------------------------------------------------------------
+ # BACKGROUND WORKER PARAMETERS (including autovacuum)
+ #------------------------------------------------------------------------------
+ 
+ #autovacuum_max_workers = 3		# max number of background helper
+ 			  		# subprocesses (for all databases)
+ 
+ #min_spare_background_helpers = 0	# min spare workers to prefork and
+ 			  		# keep waiting for jobs, per database
+ #max_spare_background_helpers = 0	# max spare helpers per database
+ 
+ 
+ 
+ #------------------------------------------------------------------------------
  # AUTOVACUUM PARAMETERS
  #------------------------------------------------------------------------------
  
! #autovacuum = on			# Enable autovacuum?  'on' requires
! 					# track_counts to also be on.
  #log_autovacuum_min_duration = -1	# -1 disables, 0 logs all actions and
  					# their durations, > 0 logs only
  					# actions running at least this number
  					# of milliseconds.
  #autovacuum_naptime = 1min		# time between autovacuum runs
  #autovacuum_vacuum_threshold = 50	# min number of row updates before
  					# vacuum
============================================================
*** src/include/storage/pmsignal.h	517450db2bab1f2a3dd7320a273b8e7320c29bac
--- src/include/storage/pmsignal.h	c8113d31e2e76fc64ad82209ff2fb8aea91f68b3
*************** typedef enum
*** 26,32 ****
  	PMSIGNAL_BEGIN_HOT_STANDBY, /* begin Hot Standby */
  	PMSIGNAL_WAKEN_ARCHIVER,	/* send a NOTIFY signal to xlog archiver */
  	PMSIGNAL_ROTATE_LOGFILE,	/* send SIGUSR1 to syslogger to rotate logfile */
- 	PMSIGNAL_START_AUTOVAC_LAUNCHER,	/* start an autovacuum launcher */
  	PMSIGNAL_START_AUTOVAC_WORKER,		/* start an autovacuum worker */
  	PMSIGNAL_START_WALRECEIVER, /* start a walreceiver */
  
--- 26,31 ----
============================================================
*** src/backend/postmaster/autovacuum.c	e0cb7d340f41ac1fd6f3d6709cb9ab42052a31ab
--- src/backend/postmaster/autovacuum.c	3b9cbe9ba0d576b32d490f21969b073a7ec55b98
***************
*** 101,108 ****
  /*
   * GUC parameters
   */
! bool		autovacuum_start_daemon = false;
  int			autovacuum_max_workers;
  int			autovacuum_naptime;
  int			autovacuum_vac_thresh;
  double		autovacuum_vac_scale;
--- 101,110 ----
  /*
   * GUC parameters
   */
! bool		autovacuum_enabled = false;
  int			autovacuum_max_workers;
+ int			min_spare_background_workers;
+ int			max_spare_background_workers;
  int			autovacuum_naptime;
  int			autovacuum_vac_thresh;
  double		autovacuum_vac_scale;
*************** typedef struct autovac_table
*** 188,199 ****
   * an array of these in shared memory, sized according to
   * autovacuum_max_workers.
   *
!  * wi_links		entry into free list or running list
!  * wi_dboid		OID of the database this worker is supposed to work on
!  * wi_tableoid	OID of the table currently being vacuumed
!  * wi_proc		pointer to PGPROC of the running worker, NULL if not started
!  * wi_launchtime Time at which this worker was launched
!  * wi_cost_*	Vacuum cost-based delay parameters current in this worker
   *
   * All fields are protected by AutovacuumLock, except for wi_tableoid which is
   * protected by AutovacuumScheduleLock (which is read-only for everyone except
--- 190,201 ----
   * an array of these in shared memory, sized according to
   * autovacuum_max_workers.
   *
!  * wi_links			entry into free list or running list
!  * wi_dboid			OID of the database this worker is supposed to work on
!  * wi_tableoid		OID of the table currently being vacuumed
!  * wi_backend_id	id of the running worker backend, NULL if not started
!  * wi_launchtime	Time at which this worker was launched
!  * wi_cost_*		Vacuum cost-based delay parameters current in this worker
   *
   * All fields are protected by AutovacuumLock, except for wi_tableoid which is
   * protected by AutovacuumScheduleLock (which is read-only for everyone except
*************** typedef struct WorkerInfoData
*** 205,211 ****
  	SHM_QUEUE	wi_links;
  	Oid			wi_dboid;
  	Oid			wi_tableoid;
! 	PGPROC	   *wi_proc;
  	TimestampTz wi_launchtime;
  	int			wi_cost_delay;
  	int			wi_cost_limit;
--- 207,213 ----
  	SHM_QUEUE	wi_links;
  	Oid			wi_dboid;
  	Oid			wi_tableoid;
! 	BackendId	wi_backend_id;
  	TimestampTz wi_launchtime;
  	int			wi_cost_delay;
  	int			wi_cost_limit;
*************** typedef struct WorkerInfoData *WorkerInf
*** 214,250 ****
  
  typedef struct WorkerInfoData *WorkerInfo;
  
- /*
-  * Possible signals received by the launcher from remote processes.  These are
-  * stored atomically in shared memory so that other processes can set them
-  * without locking.
-  */
- typedef enum
- {
- 	AutoVacForkFailed,			/* failed trying to start a worker */
- 	AutoVacRebalance,			/* rebalance the cost limits */
- 	AutoVacNumSignals			/* must be last */
- } AutoVacuumSignal;
- 
  /*-------------
   * The main autovacuum shmem struct.  On shared memory we store this main
   * struct and the array of WorkerInfo structs.	This struct keeps:
   *
!  * av_signal		set by other processes to indicate various conditions
!  * av_launcherpid	the PID of the autovacuum launcher
   * av_freeWorkers	the WorkerInfo freelist
   * av_runningWorkers the WorkerInfo non-free queue
   * av_startingWorker pointer to WorkerInfo currently being started (cleared by
   *					the worker itself as soon as it's up and running)
   *
!  * This struct is protected by AutovacuumLock, except for av_signal and parts
!  * of the worker list (see above).
   *-------------
   */
  typedef struct
  {
! 	sig_atomic_t av_signal[AutoVacNumSignals];
! 	pid_t		av_launcherpid;
  	WorkerInfo	av_freeWorkers;
  	SHM_QUEUE	av_runningWorkers;
  	WorkerInfo	av_startingWorker;
--- 216,238 ----
  
  typedef struct WorkerInfoData *WorkerInfo;
  
  /*-------------
   * The main autovacuum shmem struct.  On shared memory we store this main
   * struct and the array of WorkerInfo structs.	This struct keeps:
   *
!  * av_launcherid	the BackendId of the autovacuum launcher
   * av_freeWorkers	the WorkerInfo freelist
   * av_runningWorkers the WorkerInfo non-free queue
   * av_startingWorker pointer to WorkerInfo currently being started (cleared by
   *					the worker itself as soon as it's up and running)
   *
!  * This struct is protected by AutovacuumLock, except for parts of the worker
!  * list (see above).
   *-------------
   */
  typedef struct
  {
! 	BackendId	av_launcherid;
  	WorkerInfo	av_freeWorkers;
  	SHM_QUEUE	av_runningWorkers;
  	WorkerInfo	av_startingWorker;
*************** static WorkerInfo MyWorkerInfo = NULL;
*** 259,277 ****
  /* Pointer to my own WorkerInfo, valid on each worker */
  static WorkerInfo MyWorkerInfo = NULL;
  
- /* PID of launcher, valid only in worker while shutting down */
- int			AutovacuumLauncherPid = 0;
  
  #ifdef EXEC_BACKEND
  static pid_t avlauncher_forkexec(void);
  static pid_t avworker_forkexec(void);
  #endif
  NON_EXEC_STATIC void AutoVacWorkerMain(int argc, char *argv[]);
  NON_EXEC_STATIC void AutoVacLauncherMain(int argc, char *argv[]);
  
! static Oid	do_start_worker(void);
! static void launcher_determine_sleep(bool canlaunch, bool recursing,
! 						 struct timeval * nap);
  static void launch_worker(TimestampTz now);
  static List *get_database_list(void);
  static void rebuild_database_list(Oid newdb);
--- 247,267 ----
  /* Pointer to my own WorkerInfo, valid on each worker */
  static WorkerInfo MyWorkerInfo = NULL;
  
  
  #ifdef EXEC_BACKEND
  static pid_t avlauncher_forkexec(void);
  static pid_t avworker_forkexec(void);
  #endif
  NON_EXEC_STATIC void AutoVacWorkerMain(int argc, char *argv[]);
+ static void handle_imessage(IMessage *msg);
  NON_EXEC_STATIC void AutoVacLauncherMain(int argc, char *argv[]);
  
! static void CoordinatorMaybeTriggerAutoVacuum(void);
! 
! static void do_start_worker(avw_dbase *avdb);
! static Oid	do_start_autovacuum_worker(void);
! static void launcher_determine_sleep(bool can_launch, bool recursing,
! 									 struct timeval *nap);
  static void launch_worker(TimestampTz now);
  static List *get_database_list(void);
  static void rebuild_database_list(Oid newdb);
*************** AutoVacLauncherMain(int argc, char *argv
*** 386,391 ****
--- 376,382 ----
  AutoVacLauncherMain(int argc, char *argv[])
  {
  	sigjmp_buf	local_sigjmp_buf;
+ 	IMessage   *msg = NULL;
  
  	/* we are a postmaster subprocess now */
  	IsUnderPostmaster = true;
*************** AutoVacLauncherMain(int argc, char *argv
*** 526,540 ****
  	/* must unblock signals before calling rebuild_database_list */
  	PG_SETMASK(&UnBlockSig);
  
! 	/* in emergency mode, just start a worker and go away */
! 	if (!AutoVacuumingActive())
! 	{
! 		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
--- 517,524 ----
  	/* must unblock signals before calling rebuild_database_list */
  	PG_SETMASK(&UnBlockSig);
  
! 	AutoVacuumShmem->av_launcherid = MyBackendId;
  
  	/*
  	 * 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
*************** AutoVacLauncherMain(int argc, char *argv
*** 547,555 ****
  	for (;;)
  	{
  		struct timeval nap;
- 		TimestampTz current_time = 0;
- 		bool		can_launch;
- 		Dlelem	   *elem;
  
  		/*
  		 * Emergency bailout if postmaster has died.  This is to avoid the
--- 531,536 ----
*************** AutoVacLauncherMain(int argc, char *argv
*** 595,601 ****
  			if (!PostmasterIsAlive(true))
  				proc_exit(1);
  
! 			if (got_SIGTERM || got_SIGHUP || got_SIGUSR2)
  				break;
  		}
  
--- 576,583 ----
  			if (!PostmasterIsAlive(true))
  				proc_exit(1);
  
! 			msg = IMessageCheck();
! 			if (got_SIGTERM || got_SIGHUP || got_SIGUSR2 || msg)
  				break;
  		}
  
*************** AutoVacLauncherMain(int argc, char *argv
*** 607,619 ****
  
  		if (got_SIGHUP)
  		{
  			got_SIGHUP = false;
  			ProcessConfigFile(PGC_SIGHUP);
  
- 			/* shutdown requested in config file? */
- 			if (!AutoVacuumingActive())
- 				break;
- 
  			/* rebalance in case the default cost parameters changed */
  			LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
  			autovac_balance_cost();
--- 589,601 ----
  
  		if (got_SIGHUP)
  		{
+ #ifdef COORDINATOR_DEBUG
+ 			elog(DEBUG5, "Coordinator: got SIGHUP");
+ #endif
+ 
  			got_SIGHUP = false;
  			ProcessConfigFile(PGC_SIGHUP);
  
  			/* rebalance in case the default cost parameters changed */
  			LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
  			autovac_balance_cost();
*************** AutoVacLauncherMain(int argc, char *argv
*** 624,647 ****
  		}
  
  		/*
! 		 * a worker finished, or postmaster signalled failure to start a
! 		 * worker
  		 */
  		if (got_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
--- 606,624 ----
  		}
  
  		/*
! 		 * postmaster signalled failure to start a worker
  		 */
  		if (got_SIGUSR2)
  		{
+ #ifdef COORDINATOR_DEBUG
+ 			elog(DEBUG5, "Coordinator: got SIGUSR2");
+ #endif
+ 
  			got_SIGUSR2 = false;
  
! 			/* FIXME: fix indentation after merging */
  			{
  
  				/*
  				 * If the postmaster failed to start a new worker, we sleep
  				 * for a little while and resend the signal.  The new worker's
*************** AutoVacLauncherMain(int argc, char *argv
*** 651,665 ****
  				 * 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.
  				 */
- 				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 launcher.  First, we need to make sure that there is a
  		 * launcher slot available.  Second, we need to make sure that no
--- 628,740 ----
  				 * 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.
+ 				 *
+ 				 * FIXME: for the autovac launcher, it might have been okay
+ 				 *        to just sleep. But the coordinator needs to remain
+ 				 *        as responsive as possible, even if the postmaster
+ 				 *        is currently unable to fork new workers.
  				 */
  				pg_usleep(1000000L);	/* 1s */
  				SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER);
  				continue;
  			}
  		}
  
+ 		/* handle pending imessages */
+ 		while (msg != NULL)
+ 		{
+ 			handle_imessage(msg);
+ 			msg = IMessageCheck();
+ 		}
+ 
  		/*
+ 		 * Periodically check and trigger autovacuum workers, if autovacuum
+ 		 * is enabled.
+ 		 */
+ 		if (autovacuum_enabled)
+ 			CoordinatorMaybeTriggerAutoVacuum();
+ 	}
+ 
+ 	/* Normal exit from the autovac launcher is here */
+ 	ereport(LOG,
+ 			(errmsg("autovacuum launcher shutting down")));
+ 	AutoVacuumShmem->av_launcherid = InvalidBackendId;
+ 
+ 	proc_exit(0);				/* done */
+ }
+ 
+ void
+ handle_imessage(IMessage *msg)
+ {
+ 	IMessageType	msg_type;
+ 	BackendId		msg_sender;
+ 
+ 	msg_type = msg->type;
+ 	msg_sender = msg->sender;
+ 
+ #ifdef COORDINATOR_DEBUG
+ 	elog(DEBUG3, "Coordinator: received %s from pid %d",
+ 		 decode_imessage_type(msg->type), msg->sender);
+ #endif
+ 
+ 	switch (msg->type)
+ 	{
+ 		/*
+ 		 * Standard messages from background worker processes
+ 		 */
+ 		case IMSGT_REGISTER_WORKER:
+ 		case IMSGT_READY:
+ 			/* consume the message */
+ 			IMessageRemove(msg);
+ 
+ 			/*
+ 			 * default to immediately command the new background
+ 			 * worker to perform an autovacuum step.
+ 			 */
+ 			if (IMSGT_REGISTER_WORKER)
+ 			{
+ 				msg = IMessageCreate(IMSGT_PERFORM_VACUUM, 0);
+ 				IMessageActivate(msg, msg_sender);
+ 			}
+ 
+ 			/*
+ 			 * Rebalance cost limits, as the worker has already reported its
+ 			 * startup to the stats collector.  However, that needs to be
+ 			 * removed, so there's probably no point in rebalancing here.
+ 			 * So: FIXME.
+ 			 */
+ 			LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
+ 			autovac_balance_cost();
+ 			LWLockRelease(AutovacuumLock);
+ 
+ 			break;
+ 
+ 		case IMSGT_FORCE_VACUUM:
+ 			/* consume the message */
+ 			IMessageRemove(msg);
+ 
+ 			/* trigger an autovacuum worker */
+ 			do_start_autovacuum_worker();
+ 
+ 			break;
+ 
+ 		default:
+ 			elog(WARNING, "Unknown message type: %c, ignored!", msg->type);
+ 			IMessageRemove(msg);
+ 	}
+ }
+ 
+ static void
+ CoordinatorMaybeTriggerAutoVacuum()
+ {
+ 	TimestampTz current_time = 0;
+ 	bool		can_launch;
+ 	Dlelem	   *elem;
+ 
+ 	/* FIXME: indentation */
+ 	{
+ 
+ 		/*
  		 * There are some conditions that we need to check before trying to
  		 * start a launcher.  First, we need to make sure that there is a
  		 * launcher slot available.  Second, we need to make sure that no
*************** AutoVacLauncherMain(int argc, char *argv
*** 676,681 ****
--- 751,760 ----
  			int			waittime;
  			WorkerInfo	worker = AutoVacuumShmem->av_startingWorker;
  
+ #ifdef COORDINATOR_DEBUG
+ 			elog(DEBUG5, "Coordinator: another worker is starting...");
+ #endif
+ 
  			/*
  			 * We can't launch another worker when another one is still
  			 * starting up (or failed while doing so), so just sleep for a bit
*************** AutoVacLauncherMain(int argc, char *argv
*** 709,715 ****
  					worker = AutoVacuumShmem->av_startingWorker;
  					worker->wi_dboid = InvalidOid;
  					worker->wi_tableoid = InvalidOid;
! 					worker->wi_proc = NULL;
  					worker->wi_launchtime = 0;
  					worker->wi_links.next = (SHM_QUEUE *) AutoVacuumShmem->av_freeWorkers;
  					AutoVacuumShmem->av_freeWorkers = worker;
--- 788,794 ----
  					worker = AutoVacuumShmem->av_startingWorker;
  					worker->wi_dboid = InvalidOid;
  					worker->wi_tableoid = InvalidOid;
! 					worker->wi_backend_id = InvalidBackendId;
  					worker->wi_launchtime = 0;
  					worker->wi_links.next = (SHM_QUEUE *) AutoVacuumShmem->av_freeWorkers;
  					AutoVacuumShmem->av_freeWorkers = worker;
*************** AutoVacLauncherMain(int argc, char *argv
*** 722,730 ****
  		}
  		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 */
  
--- 801,809 ----
  		}
  		LWLockRelease(AutovacuumLock);	/* either shared or exclusive */
  
! 		/* if we can't do anything, just return. */
  		if (!can_launch)
! 			return;
  
  		/* We're OK to start a new worker */
  
*************** AutoVacLauncherMain(int argc, char *argv
*** 754,777 ****
  			launch_worker(current_time);
  		}
  	}
- 
- 	/* Normal exit from the autovac launcher is here */
- 	ereport(LOG,
- 			(errmsg("autovacuum launcher shutting down")));
- 	AutoVacuumShmem->av_launcherpid = 0;
- 
- 	proc_exit(0);				/* done */
  }
  
  /*
   * Determine the time to sleep, based on the database list.
   *
!  * The "canlaunch" parameter indicates whether we can start a worker right now,
   * for example due to the workers being all busy.  If this is false, we will
   * cause a long sleep, which will be interrupted when a worker exits.
   */
  static void
! launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
  {
  	Dlelem	   *elem;
  
--- 833,849 ----
  			launch_worker(current_time);
  		}
  	}
  }
  
  /*
   * Determine the time to sleep, based on the database list.
   *
!  * The "can_launch" parameter indicates whether we can start a worker right now,
   * for example due to the workers being all busy.  If this is false, we will
   * cause a long sleep, which will be interrupted when a worker exits.
   */
  static void
! launcher_determine_sleep(bool can_launch, bool recursing, struct timeval *nap)
  {
  	Dlelem	   *elem;
  
*************** launcher_determine_sleep(bool canlaunch,
*** 781,787 ****
  	 * in the past; if the first entry has too close a next_worker value, or a
  	 * time in the past, we will sleep a small nominal time.
  	 */
! 	if (!canlaunch)
  	{
  		nap->tv_sec = autovacuum_naptime;
  		nap->tv_usec = 0;
--- 853,859 ----
  	 * in the past; if the first entry has too close a next_worker value, or a
  	 * time in the past, we will sleep a small nominal time.
  	 */
! 	if (!can_launch)
  	{
  		nap->tv_sec = autovacuum_naptime;
  		nap->tv_usec = 0;
*************** launcher_determine_sleep(bool canlaunch,
*** 820,826 ****
  	if (nap->tv_sec == 0 && nap->tv_usec == 0 && !recursing)
  	{
  		rebuild_database_list(InvalidOid);
! 		launcher_determine_sleep(canlaunch, true, nap);
  		return;
  	}
  
--- 892,898 ----
  	if (nap->tv_sec == 0 && nap->tv_usec == 0 && !recursing)
  	{
  		rebuild_database_list(InvalidOid);
! 		launcher_determine_sleep(can_launch, true, nap);
  		return;
  	}
  
*************** db_comparator(const void *a, const void 
*** 1052,1058 ****
  /*
   * do_start_worker
   *
!  * Bare-bones procedure for starting an autovacuum worker from the launcher.
   * It determines what database to work on, sets up shared memory stuff and
   * signals postmaster to start the worker.	It fails gracefully if invoked when
   * autovacuum_workers are already active.
--- 1124,1170 ----
  /*
   * do_start_worker
   *
!  * Bare-bones procedure for starting an autovacuum worker from the
!  * coordinator. It sets up shared memory stuff and signals the postmaster to
!  * start a worker.
!  */
! void
! do_start_worker(avw_dbase *avdb)
! {
! 	WorkerInfo	worker;
! 
! #ifdef COORDINATOR_DEBUG
! 	elog(DEBUG5, "Coordinator: requesting worker for database %s",
! 		 avdb->adw_name);
! #endif
! 
! 	LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Get a worker entry from the freelist.  We checked above, so there
! 	 * really should be a free slot -- complain very loudly if there
! 	 * isn't.
! 	 */
! 	worker = AutoVacuumShmem->av_freeWorkers;
! 	if (worker == NULL)
! 		elog(FATAL, "no free worker found");
! 
! 	AutoVacuumShmem->av_freeWorkers = (WorkerInfo) worker->wi_links.next;
! 
! 	worker->wi_dboid = avdb->adw_datid;
! 	worker->wi_backend_id = InvalidBackendId;
! 	worker->wi_launchtime = GetCurrentTimestamp();
! 
! 	AutoVacuumShmem->av_startingWorker = worker;
! 
! 	LWLockRelease(AutovacuumLock);
! 
! 	SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER);
! }
! 
! /*
!  * do_start_autovacuum_worker
!  *
   * It determines what database to work on, sets up shared memory stuff and
   * signals postmaster to start the worker.	It fails gracefully if invoked when
   * autovacuum_workers are already active.
*************** static Oid
*** 1061,1067 ****
   * or InvalidOid if no worker was actually started.
   */
  static Oid
! do_start_worker(void)
  {
  	List	   *dblist;
  	ListCell   *cell;
--- 1173,1179 ----
   * or InvalidOid if no worker was actually started.
   */
  static Oid
! do_start_autovacuum_worker(void)
  {
  	List	   *dblist;
  	ListCell   *cell;
*************** do_start_worker(void)
*** 1206,1236 ****
  	/* Found a database -- process it */
  	if (avdb != NULL)
  	{
! 		WorkerInfo	worker;
! 
! 		LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
! 
! 		/*
! 		 * Get a worker entry from the freelist.  We checked above, so there
! 		 * really should be a free slot -- complain very loudly if there
! 		 * isn't.
! 		 */
! 		worker = AutoVacuumShmem->av_freeWorkers;
! 		if (worker == NULL)
! 			elog(FATAL, "no free worker found");
! 
! 		AutoVacuumShmem->av_freeWorkers = (WorkerInfo) worker->wi_links.next;
! 
! 		worker->wi_dboid = avdb->adw_datid;
! 		worker->wi_proc = NULL;
! 		worker->wi_launchtime = GetCurrentTimestamp();
! 
! 		AutoVacuumShmem->av_startingWorker = worker;
! 
! 		LWLockRelease(AutovacuumLock);
! 
! 		SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER);
! 
  		retval = avdb->adw_datid;
  	}
  	else if (skipit)
--- 1318,1324 ----
  	/* Found a database -- process it */
  	if (avdb != NULL)
  	{
! 		do_start_worker(avdb);
  		retval = avdb->adw_datid;
  	}
  	else if (skipit)
*************** do_start_worker(void)
*** 1254,1260 ****
   * Wrapper for starting a worker from the launcher.  Besides actually starting
   * it, update the database list to reflect the next time that another one will
   * need to be started on the selected database.  The actual database choice is
!  * left to do_start_worker.
   *
   * This routine is also expected to insert an entry into the database list if
   * the selected database was previously absent from the list.
--- 1342,1348 ----
   * Wrapper for starting a worker from the launcher.  Besides actually starting
   * it, update the database list to reflect the next time that another one will
   * need to be started on the selected database.  The actual database choice is
!  * left to do_start_autovacuum_worker.
   *
   * This routine is also expected to insert an entry into the database list if
   * the selected database was previously absent from the list.
*************** launch_worker(TimestampTz now)
*** 1265,1271 ****
  	Oid			dbid;
  	Dlelem	   *elem;
  
! 	dbid = do_start_worker();
  	if (OidIsValid(dbid))
  	{
  		/*
--- 1353,1359 ----
  	Oid			dbid;
  	Dlelem	   *elem;
  
! 	dbid = do_start_autovacuum_worker();
  	if (OidIsValid(dbid))
  	{
  		/*
*************** launch_worker(TimestampTz now)
*** 1304,1320 ****
  	}
  }
  
- /*
-  * Called from postmaster to signal a failure to fork a process to become
-  * worker.	The postmaster should kill(SIGUSR2) the launcher shortly
-  * after calling this function.
-  */
- void
- AutoVacWorkerFailed(void)
- {
- 	AutoVacuumShmem->av_signal[AutoVacForkFailed] = true;
- }
- 
  /* SIGHUP: set flag to re-read config file at next convenient time */
  static void
  avl_sighup_handler(SIGNAL_ARGS)
--- 1392,1397 ----
*************** avl_sighup_handler(SIGNAL_ARGS)
*** 1322,1328 ****
  	got_SIGHUP = true;
  }
  
! /* SIGUSR2: a worker is up and running, or just finished, or failed to fork */
  static void
  avl_sigusr2_handler(SIGNAL_ARGS)
  {
--- 1399,1405 ----
  	got_SIGHUP = true;
  }
  
! /* SIGUSR2: postmaster failed to fork a worker for us */
  static void
  avl_sigusr2_handler(SIGNAL_ARGS)
  {
*************** AutoVacWorkerMain(int argc, char *argv[]
*** 1421,1427 ****
--- 1498,1508 ----
  AutoVacWorkerMain(int argc, char *argv[])
  {
  	sigjmp_buf	local_sigjmp_buf;
+ 	BackendId   coordinator_id;
+ 	IMessage   *msg;
  	Oid			dbid;
+ 	char		dbname[NAMEDATALEN];
+ 	bool		terminate_worker = false;
  
  	/* we are a postmaster subprocess now */
  	IsUnderPostmaster = true;
*************** AutoVacWorkerMain(int argc, char *argv[]
*** 1537,1548 ****
  	 * launcher might have decided to remove it from the queue and start
  	 * again.
  	 */
! 	if (AutoVacuumShmem->av_startingWorker != NULL)
  	{
! 		MyWorkerInfo = AutoVacuumShmem->av_startingWorker;
! 		dbid = MyWorkerInfo->wi_dboid;
! 		MyWorkerInfo->wi_proc = MyProc;
  
  		/* insert into the running list */
  		SHMQueueInsertBefore(&AutoVacuumShmem->av_runningWorkers,
  							 &MyWorkerInfo->wi_links);
--- 1618,1637 ----
  	 * launcher might have decided to remove it from the queue and start
  	 * again.
  	 */
! 	if (AutoVacuumShmem->av_startingWorker == NULL)
  	{
! 		/* no worker entry for me, go away */
! 		elog(WARNING, "autovacuum worker started without a worker entry");
! 		LWLockRelease(AutovacuumLock);
! 		proc_exit(0);
! 	}
  
+ 	MyWorkerInfo = AutoVacuumShmem->av_startingWorker;
+ 	dbid = MyWorkerInfo->wi_dboid;
+ 
+ 	/* FIXME: indentation */
+ 	{
+ 
  		/* insert into the running list */
  		SHMQueueInsertBefore(&AutoVacuumShmem->av_runningWorkers,
  							 &MyWorkerInfo->wi_links);
*************** AutoVacWorkerMain(int argc, char *argv[]
*** 1552,1576 ****
  		 * a new worker if required
  		 */
  		AutoVacuumShmem->av_startingWorker = NULL;
- 		LWLockRelease(AutovacuumLock);
  
! 		on_shmem_exit(FreeWorkerInfo, 0);
! 
! 		/* wake up the launcher */
! 		if (AutoVacuumShmem->av_launcherpid != 0)
! 			kill(AutoVacuumShmem->av_launcherpid, SIGUSR2);
! 	}
! 	else
! 	{
! 		/* no worker entry for me, go away */
! 		elog(WARNING, "autovacuum worker started without a worker entry");
! 		dbid = InvalidOid;
  		LWLockRelease(AutovacuumLock);
- 	}
  
! 	if (OidIsValid(dbid))
! 	{
! 		char		dbname[NAMEDATALEN];
  
  		/*
  		 * Report autovac startup to the stats collector.  We deliberately do
--- 1641,1651 ----
  		 * a new worker if required
  		 */
  		AutoVacuumShmem->av_startingWorker = NULL;
  
! 		coordinator_id = AutoVacuumShmem->av_launcherid;
  		LWLockRelease(AutovacuumLock);
  
! 		on_shmem_exit(FreeWorkerInfo, 0);
  
  		/*
  		 * Report autovac startup to the stats collector.  We deliberately do
*************** AutoVacWorkerMain(int argc, char *argv[]
*** 1593,1613 ****
  		set_ps_display(dbname, false);
  		ereport(DEBUG1,
  				(errmsg("autovacuum: processing database \"%s\"", dbname)));
  
! 		if (PostAuthDelay)
! 			pg_usleep(PostAuthDelay * 1000000L);
  
! 		/* And do an appropriate amount of work */
! 		recentXid = ReadNewTransactionId();
! 		do_autovacuum();
  	}
  
! 	/*
! 	 * The launcher will be notified of my death in ProcKill, *if* we managed
! 	 * to get a worker slot at all
! 	 */
  
  	/* All done, go away */
  	proc_exit(0);
  }
  
--- 1668,1765 ----
  		set_ps_display(dbname, false);
  		ereport(DEBUG1,
  				(errmsg("autovacuum: processing database \"%s\"", dbname)));
+ 	}
  
! 	MyWorkerInfo->wi_backend_id = MyBackendId;
  
! 	/* register with the coordinator */
! 	if (coordinator_id != InvalidBackendId)
! 	{
! 		msg = IMessageCreate(IMSGT_REGISTER_WORKER, 0);
! 		IMessageActivate(msg, coordinator_id);
  	}
  
! 	if (PostAuthDelay)
! 		pg_usleep(PostAuthDelay * 1000000L);
  
+ 	while (!terminate_worker)
+ 	{
+ 		CHECK_FOR_INTERRUPTS();
+ 
+ 		ImmediateInterruptOK = true;
+ 		pg_usleep(1000000L);
+ 		ImmediateInterruptOK = false;
+ 
+ 		while ((msg = IMessageCheck()) && !terminate_worker)
+ 		{
+ #ifdef COORDINATOR_DEBUG
+ 			ereport(DEBUG3,
+ 					(errmsg("bg worker [%d/%d]: received message %s of size %d "
+ 							"from backend id %d, db %d",
+ 							MyProcPid, MyBackendId,
+ 							decode_imessage_type(msg->type),
+ 							msg->size, msg->sender,
+ 							MyDatabaseId)));
+ #endif
+ 
+ 			/*
+ 			 * StartTransactionCommand and CommitTransactionCommand will
+ 			 * automatically switch to other contexts.  None the less we need
+ 			 * this one for other book-keeping of the various background
+ 			 * jobs across transactions, for example to keep the list of
+ 			 * relations to vacuum.
+ 			 */
+ 			AutovacMemCxt = AllocSetContextCreate(TopMemoryContext,
+ 												  "Background Worker",
+ 												  ALLOCSET_DEFAULT_MINSIZE,
+ 												  ALLOCSET_DEFAULT_INITSIZE,
+ 												  ALLOCSET_DEFAULT_MAXSIZE);
+ 			MemoryContextSwitchTo(AutovacMemCxt);
+ 
+ 			switch (msg->type)
+ 			{
+ 				case IMSGT_PERFORM_VACUUM:
+ 					/* immediately remove the message to free shared memory */
+ 					IMessageRemove(msg);
+ 
+ 					/* do an appropriate amount of work */
+ 					do_autovacuum();
+ 
+ 
+ 					/*
+ 					 * send an IMSGT_READY to inform the coordinator that we
+ 					 * finished vacuuming.
+ 					 */
+ 					msg = IMessageCreate(IMSGT_READY, 0);
+ 					IMessageActivate(msg, GetAutovacuumLauncherId());
+ 
+ 					/*
+ 					 * for now, we always terminate the worker after an 
+ 					 * autovacuum job.
+ 					 */
+ 					terminate_worker = true;
+ 					break;
+ 
+ 				default:
+ 					ereport(WARNING,
+ 							(errmsg("bg worker [%d]: invalid message type "
+ 									"'%c' ignored",
+ 									MyProcPid, msg->type)));
+ 
+ 					/* keep shared memory clean */
+ 					IMessageRemove(msg);
+ 			}
+ 
+ 			MemoryContextSwitchTo(TopMemoryContext);
+ 			MemoryContextDelete(AutovacMemCxt);
+ 
+ 			CHECK_FOR_INTERRUPTS();
+ 		}
+ 	}
+ 
  	/* All done, go away */
+ 	ereport(DEBUG1, (errmsg("bg worker [%d/%d]: terminating",
+ 							MyProcPid, MyBackendId)));
  	proc_exit(0);
  }
  
*************** FreeWorkerInfo(int code, Datum arg)
*** 1621,1645 ****
  	{
  		LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
  
- 		/*
- 		 * Wake the launcher up so that he can launch a new worker immediately
- 		 * if required.  We only save the launcher's PID in local memory here;
- 		 * the actual signal will be sent when the PGPROC is recycled.	Note
- 		 * that we always do this, so that the launcher can rebalance the cost
- 		 * limit setting of the remaining workers.
- 		 *
- 		 * We somewhat ignore the risk that the launcher changes its PID
- 		 * between we reading it and the actual kill; we expect ProcKill to be
- 		 * called shortly after us, and we assume that PIDs are not reused too
- 		 * quickly after a process exits.
- 		 */
- 		AutovacuumLauncherPid = AutoVacuumShmem->av_launcherpid;
- 
  		SHMQueueDelete(&MyWorkerInfo->wi_links);
  		MyWorkerInfo->wi_links.next = (SHM_QUEUE *) AutoVacuumShmem->av_freeWorkers;
  		MyWorkerInfo->wi_dboid = InvalidOid;
  		MyWorkerInfo->wi_tableoid = InvalidOid;
! 		MyWorkerInfo->wi_proc = NULL;
  		MyWorkerInfo->wi_launchtime = 0;
  		MyWorkerInfo->wi_cost_delay = 0;
  		MyWorkerInfo->wi_cost_limit = 0;
--- 1773,1783 ----
  	{
  		LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
  
  		SHMQueueDelete(&MyWorkerInfo->wi_links);
  		MyWorkerInfo->wi_links.next = (SHM_QUEUE *) AutoVacuumShmem->av_freeWorkers;
  		MyWorkerInfo->wi_dboid = InvalidOid;
  		MyWorkerInfo->wi_tableoid = InvalidOid;
! 		MyWorkerInfo->wi_backend_id = InvalidBackendId;
  		MyWorkerInfo->wi_launchtime = 0;
  		MyWorkerInfo->wi_cost_delay = 0;
  		MyWorkerInfo->wi_cost_limit = 0;
*************** FreeWorkerInfo(int code, Datum arg)
*** 1648,1658 ****
  		/* not mine anymore */
  		MyWorkerInfo = NULL;
  
- 		/*
- 		 * now that we're inactive, cause a rebalancing of the surviving
- 		 * workers
- 		 */
- 		AutoVacuumShmem->av_signal[AutoVacRebalance] = true;
  		LWLockRelease(AutovacuumLock);
  	}
  }
--- 1786,1791 ----
*************** autovac_balance_cost(void)
*** 1704,1710 ****
  									   offsetof(WorkerInfoData, wi_links));
  	while (worker)
  	{
! 		if (worker->wi_proc != NULL &&
  			worker->wi_cost_limit_base > 0 && worker->wi_cost_delay > 0)
  			cost_total +=
  				(double) worker->wi_cost_limit_base / worker->wi_cost_delay;
--- 1837,1843 ----
  									   offsetof(WorkerInfoData, wi_links));
  	while (worker)
  	{
! 		if (worker->wi_backend_id != InvalidBackendId &&
  			worker->wi_cost_limit_base > 0 && worker->wi_cost_delay > 0)
  			cost_total +=
  				(double) worker->wi_cost_limit_base / worker->wi_cost_delay;
*************** autovac_balance_cost(void)
*** 1727,1733 ****
  									   offsetof(WorkerInfoData, wi_links));
  	while (worker)
  	{
! 		if (worker->wi_proc != NULL &&
  			worker->wi_cost_limit_base > 0 && worker->wi_cost_delay > 0)
  		{
  			int			limit = (int)
--- 1860,1866 ----
  									   offsetof(WorkerInfoData, wi_links));
  	while (worker)
  	{
! 		if (worker->wi_backend_id != InvalidBackendId &&
  			worker->wi_cost_limit_base > 0 && worker->wi_cost_delay > 0)
  		{
  			int			limit = (int)
*************** autovac_balance_cost(void)
*** 1739,1746 ****
  			 */
  			worker->wi_cost_limit = Max(Min(limit, worker->wi_cost_limit_base), 1);
  
! 			elog(DEBUG2, "autovac_balance_cost(pid=%u db=%u, rel=%u, cost_limit=%d, cost_delay=%d)",
! 				 worker->wi_proc->pid, worker->wi_dboid,
  				 worker->wi_tableoid, worker->wi_cost_limit, worker->wi_cost_delay);
  		}
  
--- 1872,1879 ----
  			 */
  			worker->wi_cost_limit = Max(Min(limit, worker->wi_cost_limit_base), 1);
  
! 			elog(DEBUG2, "autovac_balance_cost(backend_id=%u db=%u, rel=%u, cost_limit=%d, cost_delay=%d)",
! 				 worker->wi_backend_id, worker->wi_dboid,
  				 worker->wi_tableoid, worker->wi_cost_limit, worker->wi_cost_delay);
  		}
  
*************** do_autovacuum(void)
*** 1830,1846 ****
  	ScanKeyData key;
  	TupleDesc	pg_class_desc;
  
! 	/*
! 	 * StartTransactionCommand and CommitTransactionCommand will automatically
! 	 * switch to other contexts.  We need this one to keep the list of
! 	 * relations to vacuum/analyze across transactions.
! 	 */
! 	AutovacMemCxt = AllocSetContextCreate(TopMemoryContext,
! 										  "AV worker",
! 										  ALLOCSET_DEFAULT_MINSIZE,
! 										  ALLOCSET_DEFAULT_INITSIZE,
! 										  ALLOCSET_DEFAULT_MAXSIZE);
! 	MemoryContextSwitchTo(AutovacMemCxt);
  
  	/*
  	 * may be NULL if we couldn't find an entry (only happens if we are
--- 1963,1969 ----
  	ScanKeyData key;
  	TupleDesc	pg_class_desc;
  
! 	recentXid = ReadNewTransactionId();
  
  	/*
  	 * may be NULL if we couldn't find an entry (only happens if we are
*************** autovac_report_activity(autovac_table *t
*** 2694,2712 ****
  }
  
  /*
-  * AutoVacuumingActive
-  *		Check GUC vars and report whether the autovacuum process should be
-  *		running.
-  */
- bool
- AutoVacuumingActive(void)
- {
- 	if (!autovacuum_start_daemon || !pgstat_track_counts)
- 		return false;
- 	return true;
- }
- 
- /*
   * autovac_init
   *		This is called at postmaster initialization.
   *
--- 2817,2822 ----
*************** autovac_init(void)
*** 2715,2723 ****
  void
  autovac_init(void)
  {
! 	if (autovacuum_start_daemon && !pgstat_track_counts)
  		ereport(WARNING,
! 				(errmsg("autovacuum not started because of misconfiguration"),
  				 errhint("Enable the \"track_counts\" option.")));
  }
  
--- 2825,2833 ----
  void
  autovac_init(void)
  {
! 	if (autovacuum_enabled && !pgstat_track_counts)
  		ereport(WARNING,
! 				(errmsg("autovacuum disabled because of misconfiguration"),
  				 errhint("Enable the \"track_counts\" option.")));
  }
  
*************** IsAutoVacuumWorkerProcess(void)
*** 2738,2744 ****
--- 2848,2869 ----
  	return am_autovacuum_worker;
  }
  
+ /*
+  * GetAutovacuumLauncherId
+  *     Returns the backendId of the currently active coordinator process.
+  */ 
+ BackendId
+ GetAutovacuumLauncherId(void)
+ {
+ 	BackendId AutovacuumLauncherId;
  
+ 	LWLockAcquire(AutovacuumLock, LW_SHARED);
+ 	AutovacuumLauncherId = AutoVacuumShmem->av_launcherid;
+ 	LWLockRelease(AutovacuumLock);
+    
+ 	return AutovacuumLauncherId;
+ }
+ 
  /*
   * AutoVacuumShmemSize
   *		Compute space needed for autovacuum-related shared memory
*************** AutoVacuumShmemInit(void)
*** 2779,2785 ****
  
  		Assert(!found);
  
! 		AutoVacuumShmem->av_launcherpid = 0;
  		AutoVacuumShmem->av_freeWorkers = NULL;
  		SHMQueueInit(&AutoVacuumShmem->av_runningWorkers);
  		AutoVacuumShmem->av_startingWorker = NULL;
--- 2904,2910 ----
  
  		Assert(!found);
  
! 		AutoVacuumShmem->av_launcherid = InvalidBackendId;
  		AutoVacuumShmem->av_freeWorkers = NULL;
  		SHMQueueInit(&AutoVacuumShmem->av_runningWorkers);
  		AutoVacuumShmem->av_startingWorker = NULL;
============================================================
*** src/include/postmaster/autovacuum.h	0bae2233087c757cad1e627118530e452ba166e7
--- src/include/postmaster/autovacuum.h	9d1ae53662236fcc871f84a9b1036619931bffe6
***************
*** 14,24 ****
  #ifndef AUTOVACUUM_H
  #define AUTOVACUUM_H
  
  #include "storage/lock.h"
  
  /* GUC variables */
! extern bool autovacuum_start_daemon;
  extern int	autovacuum_max_workers;
  extern int	autovacuum_naptime;
  extern int	autovacuum_vac_thresh;
  extern double autovacuum_vac_scale;
--- 14,27 ----
  #ifndef AUTOVACUUM_H
  #define AUTOVACUUM_H
  
+ #include "storage/imsg.h"
  #include "storage/lock.h"
  
  /* GUC variables */
! extern bool autovacuum_enabled;
  extern int	autovacuum_max_workers;
+ extern int min_spare_background_workers;
+ extern int max_spare_background_workers;
  extern int	autovacuum_naptime;
  extern int	autovacuum_vac_thresh;
  extern double autovacuum_vac_scale;
*************** extern int	autovacuum_vac_cost_limit;
*** 28,54 ****
  extern int	autovacuum_vac_cost_delay;
  extern int	autovacuum_vac_cost_limit;
  
- /* autovacuum launcher PID, only valid when worker is shutting down */
- extern int	AutovacuumLauncherPid;
- 
  extern int	Log_autovacuum_min_duration;
  
  /* Status inquiry functions */
- extern bool AutoVacuumingActive(void);
  extern bool IsAutoVacuumLauncherProcess(void);
  extern bool IsAutoVacuumWorkerProcess(void);
  
- #define IsAnyAutoVacuumProcess() \
- 	(IsAutoVacuumLauncherProcess() || IsAutoVacuumWorkerProcess())
- 
  /* Functions to start autovacuum process, called from postmaster */
  extern void autovac_init(void);
  extern int	StartAutoVacLauncher(void);
  extern int	StartAutoVacWorker(void);
  
- /* called from postmaster when a worker could not be forked */
- extern void AutoVacWorkerFailed(void);
- 
  /* autovacuum cost-delay balancer */
  extern void AutoVacuumUpdateDelay(void);
  
--- 31,48 ----
  extern int	autovacuum_vac_cost_delay;
  extern int	autovacuum_vac_cost_limit;
  
  extern int	Log_autovacuum_min_duration;
  
  /* Status inquiry functions */
  extern bool IsAutoVacuumLauncherProcess(void);
  extern bool IsAutoVacuumWorkerProcess(void);
+ extern BackendId GetAutovacuumLauncherId(void);
  
  /* Functions to start autovacuum process, called from postmaster */
  extern void autovac_init(void);
  extern int	StartAutoVacLauncher(void);
  extern int	StartAutoVacWorker(void);
  
  /* autovacuum cost-delay balancer */
  extern void AutoVacuumUpdateDelay(void);
  
============================================================
*** src/backend/storage/ipc/imsg.c	dc149eef487eafb43409a78b8a33c70e7d3c2bfa
--- src/backend/storage/ipc/imsg.c	81f58ac6067b9e4ebfaaf1e8ada1df68a20e8493
*************** decode_imessage_type(const IMessageType 
*** 79,84 ****
--- 79,95 ----
  	{
  		case IMSGT_TEST:
  			return "IMSGT_TEST";
+ 
+ 		case IMSGT_REGISTER_WORKER:
+ 			return "IMSGT_REGISTER_WORKER";
+ 		case IMSGT_READY:
+ 			return "IMSGT_READY";
+ 
+ 		case IMSGT_PERFORM_VACUUM:
+ 			return "IMSGT_PERFORM_VACUUM";
+ 		case IMSGT_FORCE_VACUUM:
+ 			return "IMSGT_FORCE_VACUUM";
+ 
  		default:
  			return "unknown message type";
  	}
============================================================
*** src/include/storage/imsg.h	d7d3960f42396bef49eb598411c215271570330e
--- src/include/storage/imsg.h	33f7d6772ba8d599a4eed0b882ccfa474a5cf258
*************** typedef enum
*** 28,33 ****
--- 28,47 ----
   */
  typedef enum
  {
+ 	/*
+ 	 * messages from worker to coordinator, for background worker
+ 	 * registration and job management.
+ 	 */
+ 	IMSGT_REGISTER_WORKER = 'W',
+ 	IMSGT_READY = 'r',
+ 
+ 	/* inform the coordinator about a database that needs vacuuming to
+ 	 * prevent transaction wrap around, from backends to coordinator */
+ 	IMSGT_FORCE_VACUUM = 'v',
+ 
+ 	/* messages from coordinator to worker */
+ 	IMSGT_PERFORM_VACUUM = 'V',
+ 
  	IMSGT_TEST = 'T'				/* test message type */
  } IMessageType;