Improve realloc() per idea from Karel Zak --- if chunk to be enlarged is

at end of its block, maybe we can enlarge it in-place.

diff --git a/src/backend/utils/mmgr/aset.c b/src/backend/utils/mmgr/aset.c
index 5c0cf3074531a92da0e0afa912e8a14179ef87ce..c78008824b5271f672b1559238aae6ecfbd7612d 100644 (file)
--- a/src/backend/utils/mmgr/aset.c
+++ b/src/backend/utils/mmgr/aset.c
@@ -11,7 +11,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/utils/mmgr/aset.c,v 1.37 2001/01/12 21:54:01 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/utils/mmgr/aset.c,v 1.38 2001/01/23 01:01:36 tgl Exp $
  *
  * NOTE:
  *     This is a new (Feb. 05, 1999) implementation of the allocation set
@@ -879,10 +879,60 @@ AllocSetRealloc(MemoryContext context, void *pointer, Size size)
        }
        else
        {
+               /*
+                * Small-chunk case.  If the chunk is the last one in its block,
+                * there might be enough free space after it that we can just
+                * enlarge the chunk in-place.  It's relatively painful to find
+                * the containing block in the general case, but we can detect
+                * last-ness quite cheaply for the typical case where the chunk
+                * is in the active (topmost) allocation block.  (At least with
+                * the regression tests and code as of 1/2001, realloc'ing the last
+                * chunk of a non-topmost block hardly ever happens, so it's not
+                * worth scanning the block list to catch that case.)
+                *
+                * NOTE: must be careful not to create a chunk of a size that
+                * AllocSetAlloc would not create, else we'll get confused later.
+                */
+               AllocPointer newPointer;
+
+               if (size <= ALLOC_CHUNK_LIMIT)
+               {
+                       AllocBlock      block = set->blocks;
+                       char       *chunk_end;
+
+                       chunk_end = (char *) chunk + (oldsize + ALLOC_CHUNKHDRSZ);
+                       if (chunk_end == block->freeptr)
+                       { 
+                               /* OK, it's last in block ... is there room? */
+                               Size    freespace = block->endptr - block->freeptr;
+                               int             fidx;
+                               Size    newsize;
+                               Size    delta;
+
+                               fidx = AllocSetFreeIndex(size);
+                               newsize = 1 << (fidx + ALLOC_MINBITS);
+                               Assert(newsize >= oldsize);
+                               delta = newsize - oldsize;
+                               if (freespace >= delta)
+                               {
+                                       /* Yes, so just enlarge the chunk. */
+                                       block->freeptr += delta;
+                                       chunk->size += delta;
+#ifdef MEMORY_CONTEXT_CHECKING         
+                                       chunk->requested_size = size;
+                                       /* set mark to catch clobber of "unused" space */
+                                       if (size < chunk->size)
+                                               ((char *) pointer)[size] = 0x7E;
+#endif
+                                       return pointer;
+                               }
+                       }
+               }
+
                /* Normal small-chunk case: just do it by brute force. */
 
                /* allocate new chunk */
-               AllocPointer newPointer = AllocSetAlloc((MemoryContext) set, size);
+               newPointer = AllocSetAlloc((MemoryContext) set, size);
 
                /* transfer existing data (certain to fit) */
                memcpy(newPointer, pointer, oldsize);