postgres
diff --git a/‎contrib/amcheck/verify_nbtree.c
Lines changed: 1 addition & 3 deletions b/‎contrib/amcheck/verify_nbtree.c
Lines changed: 1 addition & 3 deletions
diff --git a/‎src/backend/access/transam/xact.c
Lines changed: 6 additions & 5 deletions b/‎src/backend/access/transam/xact.c
Lines changed: 6 additions & 5 deletions
diff --git a/‎src/backend/catalog/partition.c
Lines changed: 4 additions & 3 deletions b/‎src/backend/catalog/partition.c
Lines changed: 4 additions & 3 deletions
diff --git a/‎src/backend/commands/subscriptioncmds.c
Lines changed: 1 addition & 3 deletions b/‎src/backend/commands/subscriptioncmds.c
Lines changed: 1 addition & 3 deletions
diff --git a/‎src/backend/lib/knapsack.c
Lines changed: 1 addition & 3 deletions b/‎src/backend/lib/knapsack.c
Lines changed: 1 addition & 3 deletions
diff --git a/‎src/backend/replication/logical/launcher.c
Lines changed: 1 addition & 3 deletions b/‎src/backend/replication/logical/launcher.c
Lines changed: 1 addition & 3 deletions
diff --git a/‎src/backend/replication/logical/reorderbuffer.c
Lines changed: 3 additions & 0 deletions b/‎src/backend/replication/logical/reorderbuffer.c
Lines changed: 3 additions & 0 deletions
diff --git a/‎src/backend/replication/pgoutput/pgoutput.c
Lines changed: 1 addition & 3 deletions b/‎src/backend/replication/pgoutput/pgoutput.c
Lines changed: 1 addition & 3 deletions
diff --git a/‎src/backend/utils/cache/relcache.c
Lines changed: 17 additions & 12 deletions b/‎src/backend/utils/cache/relcache.c
Lines changed: 17 additions & 12 deletions
diff --git a/‎src/backend/utils/cache/ts_cache.c
Lines changed: 4 additions & 3 deletions b/‎src/backend/utils/cache/ts_cache.c
Lines changed: 4 additions & 3 deletions
diff --git a/‎src/backend/utils/hash/dynahash.c
Lines changed: 5 additions & 3 deletions b/‎src/backend/utils/hash/dynahash.c
Lines changed: 5 additions & 3 deletions
diff --git a/‎src/backend/utils/mmgr/README
Lines changed: 5 additions & 7 deletions b/‎src/backend/utils/mmgr/README
Lines changed: 5 additions & 7 deletions
@@ -295,9 +295,7 @@ bt_check_every_level(Relation rel, bool readonly)
 	/* Create context for page */
 	state->targetcontext = AllocSetContextCreate(CurrentMemoryContext,
 												 "amcheck context",
-												 ALLOCSET_DEFAULT_MINSIZE,
-												 ALLOCSET_DEFAULT_INITSIZE,
-												 ALLOCSET_DEFAULT_MAXSIZE);
+												 ALLOCSET_DEFAULT_SIZES);
 	state->checkstrategy = GetAccessStrategy(BAS_BULKREAD);
 
 	/* Get true root block from meta-page */
 
@@ -997,11 +997,12 @@ AtStart_Memory(void)
 	 */
 	if (TransactionAbortContext == NULL)
 		TransactionAbortContext =
-			AllocSetContextCreate(TopMemoryContext,
-								  "TransactionAbortContext",
-								  32 * 1024,
-								  32 * 1024,
-								  32 * 1024);
+			AllocSetContextCreateExtended(TopMemoryContext,
+										  "TransactionAbortContext",
+										  0,
+										  32 * 1024,
+										  32 * 1024,
+										  32 * 1024);
 
 	/*
 	 * We shouldn't have a transaction context already.
 
@@ -520,9 +520,10 @@ RelationBuildPartitionDesc(Relation rel)
 	}
 
 	/* Now build the actual relcache partition descriptor */
-	rel->rd_pdcxt = AllocSetContextCreate(CacheMemoryContext,
-										  RelationGetRelationName(rel),
-										  ALLOCSET_DEFAULT_SIZES);
+	rel->rd_pdcxt = AllocSetContextCreateExtended(CacheMemoryContext,
+												  RelationGetRelationName(rel),
+												  MEMCONTEXT_COPY_NAME,
+												  ALLOCSET_DEFAULT_SIZES);
 	oldcxt = MemoryContextSwitchTo(rel->rd_pdcxt);
 
 	result = (PartitionDescData *) palloc0(sizeof(PartitionDescData));
 
@@ -259,9 +259,7 @@ publicationListToArray(List *publist)
 	/* Create memory context for temporary allocations. */
 	memcxt = AllocSetContextCreate(CurrentMemoryContext,
 								   "publicationListToArray to array",
-								   ALLOCSET_DEFAULT_MINSIZE,
-								   ALLOCSET_DEFAULT_INITSIZE,
-								   ALLOCSET_DEFAULT_MAXSIZE);
+								   ALLOCSET_DEFAULT_SIZES);
 	oldcxt = MemoryContextSwitchTo(memcxt);
 
 	datums = (Datum *) palloc(sizeof(Datum) * list_length(publist));
 
@@ -57,9 +57,7 @@ DiscreteKnapsack(int max_weight, int num_items,
 {
 	MemoryContext local_ctx = AllocSetContextCreate(CurrentMemoryContext,
 													"Knapsack",
-													ALLOCSET_SMALL_MINSIZE,
-													ALLOCSET_SMALL_INITSIZE,
-													ALLOCSET_SMALL_MAXSIZE);
+													ALLOCSET_SMALL_SIZES);
 	MemoryContext oldctx = MemoryContextSwitchTo(local_ctx);
 	double	   *values;
 	Bitmapset **sets;
 
@@ -925,9 +925,7 @@ ApplyLauncherMain(Datum main_arg)
 			/* Use temporary context for the database list and worker info. */
 			subctx = AllocSetContextCreate(TopMemoryContext,
 										   "Logical Replication Launcher sublist",
-										   ALLOCSET_DEFAULT_MINSIZE,
-										   ALLOCSET_DEFAULT_INITSIZE,
-										   ALLOCSET_DEFAULT_MAXSIZE);
+										   ALLOCSET_DEFAULT_SIZES);
 			oldctx = MemoryContextSwitchTo(subctx);
 
 			/* search for subscriptions to start or stop. */
 
@@ -237,16 +237,19 @@ ReorderBufferAllocate(void)
 
 	buffer->change_context = SlabContextCreate(new_ctx,
 											   "Change",
+											   0,
 											   SLAB_DEFAULT_BLOCK_SIZE,
 											   sizeof(ReorderBufferChange));
 
 	buffer->txn_context = SlabContextCreate(new_ctx,
 											"TXN",
+											0,
 											SLAB_DEFAULT_BLOCK_SIZE,
 											sizeof(ReorderBufferTXN));
 
 	buffer->tup_context = GenerationContextCreate(new_ctx,
 												  "Tuples",
+												  0,
 												  SLAB_LARGE_BLOCK_SIZE);
 
 	hash_ctl.keysize = sizeof(TransactionId);
 
@@ -152,9 +152,7 @@ pgoutput_startup(LogicalDecodingContext *ctx, OutputPluginOptions *opt,
 	/* Create our memory context for private allocations. */
 	data->context = AllocSetContextCreate(ctx->context,
 										  "logical replication output context",
-										  ALLOCSET_DEFAULT_MINSIZE,
-										  ALLOCSET_DEFAULT_INITSIZE,
-										  ALLOCSET_DEFAULT_MAXSIZE);
+										  ALLOCSET_DEFAULT_SIZES);
 
 	ctx->output_plugin_private = data;
 
 
@@ -669,9 +669,10 @@ RelationBuildRuleLock(Relation relation)
 	/*
 	 * Make the private context.  Assume it'll not contain much data.
 	 */
-	rulescxt = AllocSetContextCreate(CacheMemoryContext,
-									 RelationGetRelationName(relation),
-									 ALLOCSET_SMALL_SIZES);
+	rulescxt = AllocSetContextCreateExtended(CacheMemoryContext,
+											 RelationGetRelationName(relation),
+											 MEMCONTEXT_COPY_NAME,
+											 ALLOCSET_SMALL_SIZES);
 	relation->rd_rulescxt = rulescxt;
 
 	/*
@@ -984,9 +985,10 @@ RelationBuildPartitionKey(Relation relation)
 	ReleaseSysCache(tuple);
 
 	/* Success --- now copy to the cache memory */
-	partkeycxt = AllocSetContextCreate(CacheMemoryContext,
-									   RelationGetRelationName(relation),
-									   ALLOCSET_SMALL_SIZES);
+	partkeycxt = AllocSetContextCreateExtended(CacheMemoryContext,
+											   RelationGetRelationName(relation),
+											   MEMCONTEXT_COPY_NAME,
+											   ALLOCSET_SMALL_SIZES);
 	relation->rd_partkeycxt = partkeycxt;
 	oldcxt = MemoryContextSwitchTo(relation->rd_partkeycxt);
 	relation->rd_partkey = copy_partition_key(key);
@@ -1566,9 +1568,10 @@ RelationInitIndexAccessInfo(Relation relation)
 	 * a context, and not just a couple of pallocs, is so that we won't leak
 	 * any subsidiary info attached to fmgr lookup records.
 	 */
-	indexcxt = AllocSetContextCreate(CacheMemoryContext,
-									 RelationGetRelationName(relation),
-									 ALLOCSET_SMALL_SIZES);
+	indexcxt = AllocSetContextCreateExtended(CacheMemoryContext,
+											 RelationGetRelationName(relation),
+											 MEMCONTEXT_COPY_NAME,
+											 ALLOCSET_SMALL_SIZES);
 	relation->rd_indexcxt = indexcxt;
 
 	/*
@@ -5537,9 +5540,11 @@ load_relcache_init_file(bool shared)
 			 * prepare index info context --- parameters should match
 			 * RelationInitIndexAccessInfo
 			 */
-			indexcxt = AllocSetContextCreate(CacheMemoryContext,
-											 RelationGetRelationName(rel),
-											 ALLOCSET_SMALL_SIZES);
+			indexcxt =
+				AllocSetContextCreateExtended(CacheMemoryContext,
+											  RelationGetRelationName(rel),
+											  MEMCONTEXT_COPY_NAME,
+											  ALLOCSET_SMALL_SIZES);
 			rel->rd_indexcxt = indexcxt;
 
 			/*
 
@@ -294,9 +294,10 @@ lookup_ts_dictionary_cache(Oid dictId)
 			Assert(!found);		/* it wasn't there a moment ago */
 
 			/* Create private memory context the first time through */
-			saveCtx = AllocSetContextCreate(CacheMemoryContext,
-											NameStr(dict->dictname),
-											ALLOCSET_SMALL_SIZES);
+			saveCtx = AllocSetContextCreateExtended(CacheMemoryContext,
+													NameStr(dict->dictname),
+													MEMCONTEXT_COPY_NAME,
+													ALLOCSET_SMALL_SIZES);
 		}
 		else
 		{
 
@@ -340,9 +340,11 @@ hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
 			CurrentDynaHashCxt = info->hcxt;
 		else
 			CurrentDynaHashCxt = TopMemoryContext;
-		CurrentDynaHashCxt = AllocSetContextCreate(CurrentDynaHashCxt,
-												   tabname,
-												   ALLOCSET_DEFAULT_SIZES);
+		CurrentDynaHashCxt =
+			AllocSetContextCreateExtended(CurrentDynaHashCxt,
+										  tabname,
+										  MEMCONTEXT_COPY_NAME,
+										  ALLOCSET_DEFAULT_SIZES);
 	}
 
 	/* Initialize the hash header, plus a copy of the table name */
 
@@ -177,8 +177,7 @@ every other context is a direct or indirect child of this one.  Allocating
 here is essentially the same as "malloc", because this context will never
 be reset or deleted.  This is for stuff that should live forever, or for
 stuff that the controlling module will take care of deleting at the
-appropriate time.  An example is fd.c's tables of open files, as well as
-the context management nodes for memory contexts themselves.  Avoid
+appropriate time.  An example is fd.c's tables of open files.  Avoid
 allocating stuff here unless really necessary, and especially avoid
 running with CurrentMemoryContext pointing here.
 
@@ -420,11 +419,10 @@ a maximum block size.  Selecting smaller values can prevent wastage of
 space in contexts that aren't expected to hold very much (an example
 is the relcache's per-relation contexts).
 
-Also, it is possible to specify a minimum context size.  If this
-value is greater than zero then a block of that size will be grabbed
-immediately upon context creation, and cleared but not released during
-context resets.  This feature is needed for ErrorContext (see above),
-but will most likely not be used for other contexts.
+Also, it is possible to specify a minimum context size, in case for some
+reason that should be different from the initial size for additional
+blocks.  An aset.c context will always contain at least one block,
+of size minContextSize if that is specified, otherwise initBlockSize.
 
 We expect that per-tuple contexts will be reset frequently and typically
 will not allocate very much space per tuple cycle.  To make this usage