Rename various "freeze multixact" variables

It seems to make more sense to use "cutoff multixact" terminology
throughout the backend code; "freeze" is associated with replacing of an
Xid with FrozenTransactionId, which is not what we do for MultiXactIds.

Andres Freund
Some adjustments by Álvaro Herrera

11 files changed, 61 insertions, 61 deletions

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index b1a5d9f65ac..ead3d690aea 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -5135,8 +5135,8 @@ heap_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid,
 
 	/*
 	 * Note that this code handles IS_MULTI Xmax values, too, but only to mark
-	 * the tuple frozen if the updating Xid in the mxact is below the freeze
-	 * cutoff; it doesn't remove dead members of a very old multixact.
+	 * the tuple as not updated if the multixact is below the cutoff Multixact
+	 * given; it doesn't remove dead members of a very old multixact.
 	 */
 	xid = HeapTupleHeaderGetRawXmax(tuple);
 	if ((tuple->t_infomask & HEAP_XMAX_IS_MULTI) ?
diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
index 7105f0ab651..951894ce5ac 100644
--- a/src/backend/access/heap/rewriteheap.c
+++ b/src/backend/access/heap/rewriteheap.c
@@ -129,8 +129,8 @@ typedef struct RewriteStateData
 										 * determine tuple visibility */
 	TransactionId rs_freeze_xid;/* Xid that will be used as freeze cutoff
 								 * point */
-	MultiXactId rs_freeze_multi;/* MultiXactId that will be used as freeze
-								 * cutoff point for multixacts */
+	MultiXactId rs_cutoff_multi;/* MultiXactId that will be used as cutoff
+								 * point for multixacts */
 	MemoryContext rs_cxt;		/* for hash tables and entries and tuples in
 								 * them */
 	HTAB	   *rs_unresolved_tups;		/* unmatched A tuples */
@@ -180,7 +180,7 @@ static void raw_heap_insert(RewriteState state, HeapTuple tup);
  * new_heap		new, locked heap relation to insert tuples to
  * oldest_xmin	xid used by the caller to determine which tuples are dead
  * freeze_xid	xid before which tuples will be frozen
- * freeze_multi multixact before which multis will be frozen
+ * min_multi	multixact before which multis will be removed
  * use_wal		should the inserts to the new heap be WAL-logged?
  *
  * Returns an opaque RewriteState, allocated in current memory context,
@@ -188,7 +188,7 @@ static void raw_heap_insert(RewriteState state, HeapTuple tup);
  */
 RewriteState
 begin_heap_rewrite(Relation new_heap, TransactionId oldest_xmin,
-				   TransactionId freeze_xid, MultiXactId freeze_multi,
+				   TransactionId freeze_xid, MultiXactId cutoff_multi,
 				   bool use_wal)
 {
 	RewriteState state;
@@ -218,7 +218,7 @@ begin_heap_rewrite(Relation new_heap, TransactionId oldest_xmin,
 	state->rs_use_wal = use_wal;
 	state->rs_oldest_xmin = oldest_xmin;
 	state->rs_freeze_xid = freeze_xid;
-	state->rs_freeze_multi = freeze_multi;
+	state->rs_cutoff_multi = cutoff_multi;
 	state->rs_cxt = rw_cxt;
 
 	/* Initialize hash tables used to track update chains */
@@ -347,7 +347,7 @@ rewrite_heap_tuple(RewriteState state,
 	 * very-old xmin or xmax, so that future VACUUM effort can be saved.
 	 */
 	heap_freeze_tuple(new_tuple->t_data, state->rs_freeze_xid,
-					  state->rs_freeze_multi);
+					  state->rs_cutoff_multi);
 
 	/*
 	 * Invalid ctid means that ctid should point to the tuple itself. We'll
diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
index 745b1f1d891..e3f5cbc0cd9 100644
--- a/src/backend/access/transam/multixact.c
+++ b/src/backend/access/transam/multixact.c
@@ -1069,7 +1069,7 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
 	 * We check known limits on MultiXact before resorting to the SLRU area.
 	 *
 	 * An ID older than MultiXactState->oldestMultiXactId cannot possibly be
-	 * useful; it should have already been frozen by vacuum.  We've truncated
+	 * useful; it should have already been removed by vacuum.  We've truncated
 	 * the on-disk structures anyway.  Returning the wrong values could lead
 	 * to an incorrect visibility result.  However, to support pg_upgrade we
 	 * need to allow an empty set to be returned regardless, if the caller is
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index 051b806aa72..f6a5bfe8d15 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -69,7 +69,7 @@ static void rebuild_relation(Relation OldHeap, Oid indexOid,
 static void copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
 			   int freeze_min_age, int freeze_table_age, bool verbose,
 			   bool *pSwapToastByContent, TransactionId *pFreezeXid,
-			   MultiXactId *pFreezeMulti);
+			   MultiXactId *pCutoffMulti);
 static List *get_tables_to_cluster(MemoryContext cluster_context);
 static void reform_and_rewrite_tuple(HeapTuple tuple,
 						 TupleDesc oldTupDesc, TupleDesc newTupDesc,
@@ -566,7 +566,7 @@ rebuild_relation(Relation OldHeap, Oid indexOid,
 	bool		is_system_catalog;
 	bool		swap_toast_by_content;
 	TransactionId frozenXid;
-	MultiXactId frozenMulti;
+	MultiXactId cutoffMulti;
 
 	/* Mark the correct index as clustered */
 	if (OidIsValid(indexOid))
@@ -585,7 +585,7 @@ rebuild_relation(Relation OldHeap, Oid indexOid,
 	/* Copy the heap data into the new table in the desired order */
 	copy_heap_data(OIDNewHeap, tableOid, indexOid,
 				   freeze_min_age, freeze_table_age, verbose,
-				   &swap_toast_by_content, &frozenXid, &frozenMulti);
+				   &swap_toast_by_content, &frozenXid, &cutoffMulti);
 
 	/*
 	 * Swap the physical files of the target and transient tables, then
@@ -593,7 +593,7 @@ rebuild_relation(Relation OldHeap, Oid indexOid,
 	 */
 	finish_heap_swap(tableOid, OIDNewHeap, is_system_catalog,
 					 swap_toast_by_content, false, true,
-					 frozenXid, frozenMulti);
+					 frozenXid, cutoffMulti);
 }
 
 
@@ -736,12 +736,13 @@ make_new_heap(Oid OIDOldHeap, Oid NewTableSpace, bool forcetemp,
  * There are two output parameters:
  * *pSwapToastByContent is set true if toast tables must be swapped by content.
  * *pFreezeXid receives the TransactionId used as freeze cutoff point.
+ * *pCutoffMulti receives the MultiXactId used as a cutoff point.
  */
 static void
 copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
 			   int freeze_min_age, int freeze_table_age, bool verbose,
 			   bool *pSwapToastByContent, TransactionId *pFreezeXid,
-			   MultiXactId *pFreezeMulti)
+			   MultiXactId *pCutoffMulti)
 {
 	Relation	NewHeap,
 				OldHeap,
@@ -757,7 +758,7 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
 	bool		is_system_catalog;
 	TransactionId OldestXmin;
 	TransactionId FreezeXid;
-	MultiXactId MultiXactFrzLimit;
+	MultiXactId MultiXactCutoff;
 	RewriteState rwstate;
 	bool		use_sort;
 	Tuplesortstate *tuplesort;
@@ -858,7 +859,7 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
 	 */
 	vacuum_set_xid_limits(freeze_min_age, freeze_table_age,
 						  OldHeap->rd_rel->relisshared,
-						  &OldestXmin, &FreezeXid, NULL, &MultiXactFrzLimit);
+						  &OldestXmin, &FreezeXid, NULL, &MultiXactCutoff);
 
 	/*
 	 * FreezeXid will become the table's new relfrozenxid, and that mustn't go
@@ -869,14 +870,14 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
 
 	/* return selected values to caller */
 	*pFreezeXid = FreezeXid;
-	*pFreezeMulti = MultiXactFrzLimit;
+	*pCutoffMulti = MultiXactCutoff;
 
 	/* Remember if it's a system catalog */
 	is_system_catalog = IsSystemRelation(OldHeap);
 
 	/* Initialize the rewrite operation */
 	rwstate = begin_heap_rewrite(NewHeap, OldestXmin, FreezeXid,
-								 MultiXactFrzLimit, use_wal);
+								 MultiXactCutoff, use_wal);
 
 	/*
 	 * Decide whether to use an indexscan or seqscan-and-optional-sort to scan
@@ -1135,7 +1136,7 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
 					TransactionId frozenXid,
-					MultiXactId frozenMulti,
+					MultiXactId cutoffMulti,
 					Oid *mapped_tables)
 {
 	Relation	relRelation;
@@ -1246,8 +1247,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	{
 		Assert(TransactionIdIsNormal(frozenXid));
 		relform1->relfrozenxid = frozenXid;
-		Assert(MultiXactIdIsValid(frozenMulti));
-		relform1->relminmxid = frozenMulti;
+		Assert(MultiXactIdIsValid(cutoffMulti));
+		relform1->relminmxid = cutoffMulti;
 	}
 
 	/* swap size statistics too, since new rel has freshly-updated stats */
@@ -1321,7 +1322,7 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
 									frozenXid,
-									frozenMulti,
+									cutoffMulti,
 									mapped_tables);
 			}
 			else
@@ -1464,7 +1465,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 				 bool check_constraints,
 				 bool is_internal,
 				 TransactionId frozenXid,
-				 MultiXactId frozenMulti)
+				 MultiXactId cutoffMulti)
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
@@ -1481,7 +1482,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, frozenMulti, mapped_tables);
+						frozenXid, cutoffMulti, mapped_tables);
 
 	/*
 	 * If it's a system catalog, queue an sinval message to flush all
diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c
index a3a150d7008..046ded1494c 100644
--- a/src/backend/commands/dbcommands.c
+++ b/src/backend/commands/dbcommands.c
@@ -1664,7 +1664,7 @@ get_db_info(const char *name, LOCKMODE lockmode,
 				/* limit of frozen XIDs */
 				if (dbFrozenXidP)
 					*dbFrozenXidP = dbform->datfrozenxid;
-				/* limit of frozen Multixacts */
+				/* minimum MultixactId */
 				if (dbMinMultiP)
 					*dbMinMultiP = dbform->datminmxid;
 				/* default tablespace for this database */
diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index 2f2c6acb968..27aea739e6b 100644
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -64,7 +64,7 @@ static BufferAccessStrategy vac_strategy;
 
 /* non-export function prototypes */
 static List *get_rel_oids(Oid relid, const RangeVar *vacrel);
-static void vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti);
+static void vac_truncate_clog(TransactionId frozenXID, MultiXactId minMulti);
 static bool vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast,
 		   bool for_wraparound);
 
@@ -384,7 +384,7 @@ vacuum_set_xid_limits(int freeze_min_age,
 					  TransactionId *oldestXmin,
 					  TransactionId *freezeLimit,
 					  TransactionId *freezeTableLimit,
-					  MultiXactId *multiXactFrzLimit)
+					  MultiXactId *multiXactCutoff)
 {
 	int			freezemin;
 	TransactionId limit;
@@ -469,7 +469,7 @@ vacuum_set_xid_limits(int freeze_min_age,
 		*freezeTableLimit = limit;
 	}
 
-	if (multiXactFrzLimit != NULL)
+	if (multiXactCutoff != NULL)
 	{
 		MultiXactId mxLimit;
 
@@ -481,7 +481,7 @@ vacuum_set_xid_limits(int freeze_min_age,
 		if (mxLimit < FirstMultiXactId)
 			mxLimit = FirstMultiXactId;
 
-		*multiXactFrzLimit = mxLimit;
+		*multiXactCutoff = mxLimit;
 	}
 }
 
@@ -690,8 +690,8 @@ vac_update_relstats(Relation relation,
  *		Update pg_database's datfrozenxid entry for our database to be the
  *		minimum of the pg_class.relfrozenxid values.
  *
- *		Similarly, update our datfrozenmulti to be the minimum of the
- *		pg_class.relfrozenmulti values.
+ *		Similarly, update our datminmxid to be the minimum of the
+ *		pg_class.relminmxid values.
  *
  *		If we are able to advance either pg_database value, also try to
  *		truncate pg_clog and pg_multixact.
@@ -711,7 +711,7 @@ vac_update_datfrozenxid(void)
 	SysScanDesc scan;
 	HeapTuple	classTup;
 	TransactionId newFrozenXid;
-	MultiXactId newFrozenMulti;
+	MultiXactId newMinMulti;
 	bool		dirty = false;
 
 	/*
@@ -726,7 +726,7 @@ vac_update_datfrozenxid(void)
 	 * Similarly, initialize the MultiXact "min" with the value that would be
 	 * used on pg_class for new tables.  See AddNewRelationTuple().
 	 */
-	newFrozenMulti = GetOldestMultiXactId();
+	newMinMulti = GetOldestMultiXactId();
 
 	/*
 	 * We must seqscan pg_class to find the minimum Xid, because there is no
@@ -756,8 +756,8 @@ vac_update_datfrozenxid(void)
 		if (TransactionIdPrecedes(classForm->relfrozenxid, newFrozenXid))
 			newFrozenXid = classForm->relfrozenxid;
 
-		if (MultiXactIdPrecedes(classForm->relminmxid, newFrozenMulti))
-			newFrozenMulti = classForm->relminmxid;
+		if (MultiXactIdPrecedes(classForm->relminmxid, newMinMulti))
+			newMinMulti = classForm->relminmxid;
 	}
 
 	/* we're done with pg_class */
@@ -765,7 +765,7 @@ vac_update_datfrozenxid(void)
 	heap_close(relation, AccessShareLock);
 
 	Assert(TransactionIdIsNormal(newFrozenXid));
-	Assert(MultiXactIdIsValid(newFrozenMulti));
+	Assert(MultiXactIdIsValid(newMinMulti));
 
 	/* Now fetch the pg_database tuple we need to update. */
 	relation = heap_open(DatabaseRelationId, RowExclusiveLock);
@@ -787,9 +787,9 @@ vac_update_datfrozenxid(void)
 	}
 
 	/* ditto */
-	if (MultiXactIdPrecedes(dbform->datminmxid, newFrozenMulti))
+	if (MultiXactIdPrecedes(dbform->datminmxid, newMinMulti))
 	{
-		dbform->datminmxid = newFrozenMulti;
+		dbform->datminmxid = newMinMulti;
 		dirty = true;
 	}
 
@@ -805,7 +805,7 @@ vac_update_datfrozenxid(void)
 	 * this action will update that too.
 	 */
 	if (dirty || ForceTransactionIdLimitUpdate())
-		vac_truncate_clog(newFrozenXid, newFrozenMulti);
+		vac_truncate_clog(newFrozenXid, newMinMulti);
 }
 
 
@@ -824,19 +824,19 @@ vac_update_datfrozenxid(void)
  *		info is stale.
  */
 static void
-vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti)
+vac_truncate_clog(TransactionId frozenXID, MultiXactId minMulti)
 {
 	TransactionId myXID = GetCurrentTransactionId();
 	Relation	relation;
 	HeapScanDesc scan;
 	HeapTuple	tuple;
 	Oid			oldestxid_datoid;
-	Oid			oldestmulti_datoid;
+	Oid			minmulti_datoid;
 	bool		frozenAlreadyWrapped = false;
 
 	/* init oldest datoids to sync with my frozen values */
 	oldestxid_datoid = MyDatabaseId;
-	oldestmulti_datoid = MyDatabaseId;
+	minmulti_datoid = MyDatabaseId;
 
 	/*
 	 * Scan pg_database to compute the minimum datfrozenxid
@@ -869,10 +869,10 @@ vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti)
 			oldestxid_datoid = HeapTupleGetOid(tuple);
 		}
 
-		if (MultiXactIdPrecedes(dbform->datminmxid, frozenMulti))
+		if (MultiXactIdPrecedes(dbform->datminmxid, minMulti))
 		{
-			frozenMulti = dbform->datminmxid;
-			oldestmulti_datoid = HeapTupleGetOid(tuple);
+			minMulti = dbform->datminmxid;
+			minmulti_datoid = HeapTupleGetOid(tuple);
 		}
 	}
 
@@ -896,7 +896,7 @@ vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti)
 
 	/* Truncate CLOG and Multi to the oldest computed value */
 	TruncateCLOG(frozenXID);
-	TruncateMultiXact(frozenMulti);
+	TruncateMultiXact(minMulti);
 
 	/*
 	 * Update the wrap limit for GetNewTransactionId and creation of new
@@ -905,7 +905,7 @@ vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti)
 	 * signalling twice?
 	 */
 	SetTransactionIdLimit(frozenXID, oldestxid_datoid);
-	MultiXactAdvanceOldest(frozenMulti, oldestmulti_datoid);
+	MultiXactAdvanceOldest(minMulti, minmulti_datoid);
 }
 
 
diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c
index c34aa537281..bb4e03ebcbc 100644
--- a/src/backend/commands/vacuumlazy.c
+++ b/src/backend/commands/vacuumlazy.c
@@ -125,7 +125,7 @@ static int	elevel = -1;
 
 static TransactionId OldestXmin;
 static TransactionId FreezeLimit;
-static MultiXactId MultiXactFrzLimit;
+static MultiXactId MultiXactCutoff;
 
 static BufferAccessStrategy vac_strategy;
 
@@ -203,7 +203,7 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt,
 	vacuum_set_xid_limits(vacstmt->freeze_min_age, vacstmt->freeze_table_age,
 						  onerel->rd_rel->relisshared,
 						  &OldestXmin, &FreezeLimit, &freezeTableLimit,
-						  &MultiXactFrzLimit);
+						  &MultiXactCutoff);
 	scan_all = TransactionIdPrecedesOrEquals(onerel->rd_rel->relfrozenxid,
 											 freezeTableLimit);
 
@@ -273,7 +273,7 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt,
 	if (vacrelstats->scanned_pages < vacrelstats->rel_pages)
 		new_frozen_xid = InvalidTransactionId;
 
-	new_min_multi = MultiXactFrzLimit;
+	new_min_multi = MultiXactCutoff;
 	if (vacrelstats->scanned_pages < vacrelstats->rel_pages)
 		new_min_multi = InvalidMultiXactId;
 
@@ -868,7 +868,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
 				 * freezing.  Note we already have exclusive buffer lock.
 				 */
 				if (heap_freeze_tuple(tuple.t_data, FreezeLimit,
-									  MultiXactFrzLimit))
+									  MultiXactCutoff))
 					frozen[nfrozen++] = offnum;
 			}
 		}						/* scan along page */
@@ -886,7 +886,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
 				XLogRecPtr	recptr;
 
 				recptr = log_heap_freeze(onerel, buf, FreezeLimit,
-										 MultiXactFrzLimit, frozen, nfrozen);
+										 MultiXactCutoff, frozen, nfrozen);
 				PageSetLSN(page, recptr);
 			}
 		}
@@ -1231,7 +1231,7 @@ lazy_check_needs_freeze(Buffer buf)
 		tupleheader = (HeapTupleHeader) PageGetItem(page, itemid);
 
 		if (heap_tuple_needs_freeze(tupleheader, FreezeLimit,
-									MultiXactFrzLimit, buf))
+									MultiXactCutoff, buf))
 			return true;
 	}							/* scan along page */
 
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index 5b9f3480a52..8c14d0f4e44 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -163,7 +163,7 @@ typedef struct avw_dbase
 	Oid			adw_datid;
 	char	   *adw_name;
 	TransactionId adw_frozenxid;
-	MultiXactId adw_frozenmulti;
+	MultiXactId adw_minmulti;
 	PgStat_StatDBEntry *adw_entry;
 } avw_dbase;
 
@@ -1176,11 +1176,10 @@ do_start_worker(void)
 		}
 		else if (for_xid_wrap)
 			continue;			/* ignore not-at-risk DBs */
-		else if (MultiXactIdPrecedes(tmp->adw_frozenmulti, multiForceLimit))
+		else if (MultiXactIdPrecedes(tmp->adw_minmulti, multiForceLimit))
 		{
 			if (avdb == NULL ||
-				MultiXactIdPrecedes(tmp->adw_frozenmulti,
-									avdb->adw_frozenmulti))
+				MultiXactIdPrecedes(tmp->adw_minmulti, avdb->adw_minmulti))
 				avdb = tmp;
 			for_multi_wrap = true;
 			continue;
@@ -1876,7 +1875,7 @@ get_database_list(void)
 		avdb->adw_datid = HeapTupleGetOid(tup);
 		avdb->adw_name = pstrdup(NameStr(pgdatabase->datname));
 		avdb->adw_frozenxid = pgdatabase->datfrozenxid;
-		avdb->adw_frozenmulti = pgdatabase->datminmxid;
+		avdb->adw_minmulti = pgdatabase->datminmxid;
 		/* this gets set later: */
 		avdb->adw_entry = NULL;
 
diff --git a/src/include/access/rewriteheap.h b/src/include/access/rewriteheap.h
index f82d1f57347..67cf06620a0 100644
--- a/src/include/access/rewriteheap.h
+++ b/src/include/access/rewriteheap.h
@@ -21,7 +21,7 @@ typedef struct RewriteStateData *RewriteState;
 
 extern RewriteState begin_heap_rewrite(Relation NewHeap,
 				   TransactionId OldestXmin, TransactionId FreezeXid,
-				   MultiXactId MultiXactFrzLimit, bool use_wal);
+				   MultiXactId MultiXactCutoff, bool use_wal);
 extern void end_heap_rewrite(RewriteState state);
 extern void rewrite_heap_tuple(RewriteState state, HeapTuple oldTuple,
 				   HeapTuple newTuple);
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 03d9f176c57..a88731832ec 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -33,6 +33,6 @@ extern void finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 				 bool check_constraints,
 				 bool is_internal,
 				 TransactionId frozenXid,
-				 MultiXactId frozenMulti);
+				 MultiXactId minMulti);
 
 #endif   /* CLUSTER_H */
diff --git a/src/include/commands/vacuum.h b/src/include/commands/vacuum.h
index d8dd8b04ed9..08bec256ba8 100644
--- a/src/include/commands/vacuum.h
+++ b/src/include/commands/vacuum.h
@@ -160,7 +160,7 @@ extern void vacuum_set_xid_limits(int freeze_min_age, int freeze_table_age,
 					  TransactionId *oldestXmin,
 					  TransactionId *freezeLimit,
 					  TransactionId *freezeTableLimit,
-					  MultiXactId *multiXactFrzLimit);
+					  MultiXactId *multiXactCutoff);
 extern void vac_update_datfrozenxid(void);
 extern void vacuum_delay_point(void);