Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * aset.c
4 : * Allocation set definitions.
5 : *
6 : * AllocSet is our standard implementation of the abstract MemoryContext
7 : * type.
8 : *
9 : *
10 : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
11 : * Portions Copyright (c) 1994, Regents of the University of California
12 : *
13 : * IDENTIFICATION
14 : * src/backend/utils/mmgr/aset.c
15 : *
16 : * NOTE:
17 : * This is a new (Feb. 05, 1999) implementation of the allocation set
18 : * routines. AllocSet...() does not use OrderedSet...() any more.
19 : * Instead it manages allocations in a block pool by itself, combining
20 : * many small allocations in a few bigger blocks. AllocSetFree() normally
21 : * doesn't free() memory really. It just add's the free'd area to some
22 : * list for later reuse by AllocSetAlloc(). All memory blocks are free()'d
23 : * at once on AllocSetReset(), which happens when the memory context gets
24 : * destroyed.
25 : * Jan Wieck
26 : *
27 : * Performance improvement from Tom Lane, 8/99: for extremely large request
28 : * sizes, we do want to be able to give the memory back to free() as soon
29 : * as it is pfree()'d. Otherwise we risk tying up a lot of memory in
30 : * freelist entries that might never be usable. This is specially needed
31 : * when the caller is repeatedly repalloc()'ing a block bigger and bigger;
32 : * the previous instances of the block were guaranteed to be wasted until
33 : * AllocSetReset() under the old way.
34 : *
35 : * Further improvement 12/00: as the code stood, request sizes in the
36 : * midrange between "small" and "large" were handled very inefficiently,
37 : * because any sufficiently large free chunk would be used to satisfy a
38 : * request, even if it was much larger than necessary. This led to more
39 : * and more wasted space in allocated chunks over time. To fix, get rid
40 : * of the midrange behavior: we now handle only "small" power-of-2-size
41 : * chunks as chunks. Anything "large" is passed off to malloc(). Change
42 : * the number of freelists to change the small/large boundary.
43 : *
44 : *-------------------------------------------------------------------------
45 : */
46 :
47 : #include "postgres.h"
48 :
49 : #include "port/pg_bitutils.h"
50 : #include "utils/memdebug.h"
51 : #include "utils/memutils.h"
52 : #include "utils/memutils_internal.h"
53 : #include "utils/memutils_memorychunk.h"
54 :
55 : /*--------------------
56 : * Chunk freelist k holds chunks of size 1 << (k + ALLOC_MINBITS),
57 : * for k = 0 .. ALLOCSET_NUM_FREELISTS-1.
58 : *
59 : * Note that all chunks in the freelists have power-of-2 sizes. This
60 : * improves recyclability: we may waste some space, but the wasted space
61 : * should stay pretty constant as requests are made and released.
62 : *
63 : * A request too large for the last freelist is handled by allocating a
64 : * dedicated block from malloc(). The block still has a block header and
65 : * chunk header, but when the chunk is freed we'll return the whole block
66 : * to malloc(), not put it on our freelists.
67 : *
68 : * CAUTION: ALLOC_MINBITS must be large enough so that
69 : * 1<<ALLOC_MINBITS is at least MAXALIGN,
70 : * or we may fail to align the smallest chunks adequately.
71 : * 8-byte alignment is enough on all currently known machines. This 8-byte
72 : * minimum also allows us to store a pointer to the next freelist item within
73 : * the chunk of memory itself.
74 : *
75 : * With the current parameters, request sizes up to 8K are treated as chunks,
76 : * larger requests go into dedicated blocks. Change ALLOCSET_NUM_FREELISTS
77 : * to adjust the boundary point; and adjust ALLOCSET_SEPARATE_THRESHOLD in
78 : * memutils.h to agree. (Note: in contexts with small maxBlockSize, we may
79 : * set the allocChunkLimit to less than 8K, so as to avoid space wastage.)
80 : *--------------------
81 : */
82 :
83 : #define ALLOC_MINBITS 3 /* smallest chunk size is 8 bytes */
84 : #define ALLOCSET_NUM_FREELISTS 11
85 : #define ALLOC_CHUNK_LIMIT (1 << (ALLOCSET_NUM_FREELISTS-1+ALLOC_MINBITS))
86 : /* Size of largest chunk that we use a fixed size for */
87 : #define ALLOC_CHUNK_FRACTION 4
88 : /* We allow chunks to be at most 1/4 of maxBlockSize (less overhead) */
89 :
90 : /*--------------------
91 : * The first block allocated for an allocset has size initBlockSize.
92 : * Each time we have to allocate another block, we double the block size
93 : * (if possible, and without exceeding maxBlockSize), so as to reduce
94 : * the bookkeeping load on malloc().
95 : *
96 : * Blocks allocated to hold oversize chunks do not follow this rule, however;
97 : * they are just however big they need to be to hold that single chunk.
98 : *
99 : * Also, if a minContextSize is specified, the first block has that size,
100 : * and then initBlockSize is used for the next one.
101 : *--------------------
102 : */
103 :
104 : #define ALLOC_BLOCKHDRSZ MAXALIGN(sizeof(AllocBlockData))
105 : #define ALLOC_CHUNKHDRSZ sizeof(MemoryChunk)
106 :
107 : typedef struct AllocBlockData *AllocBlock; /* forward reference */
108 :
109 : /*
110 : * AllocPointer
111 : * Aligned pointer which may be a member of an allocation set.
112 : */
113 : typedef void *AllocPointer;
114 :
115 : /*
116 : * AllocFreeListLink
117 : * When pfreeing memory, if we maintain a freelist for the given chunk's
118 : * size then we use a AllocFreeListLink to point to the current item in
119 : * the AllocSetContext's freelist and then set the given freelist element
120 : * to point to the chunk being freed.
121 : */
122 : typedef struct AllocFreeListLink
123 : {
124 : MemoryChunk *next;
125 : } AllocFreeListLink;
126 :
127 : /*
128 : * Obtain a AllocFreeListLink for the given chunk. Allocation sizes are
129 : * always at least sizeof(AllocFreeListLink), so we reuse the pointer's memory
130 : * itself to store the freelist link.
131 : */
132 : #define GetFreeListLink(chkptr) \
133 : (AllocFreeListLink *) ((char *) (chkptr) + ALLOC_CHUNKHDRSZ)
134 :
135 : /* Validate a freelist index retrieved from a chunk header */
136 : #define FreeListIdxIsValid(fidx) \
137 : ((fidx) >= 0 && (fidx) < ALLOCSET_NUM_FREELISTS)
138 :
139 : /* Determine the size of the chunk based on the freelist index */
140 : #define GetChunkSizeFromFreeListIdx(fidx) \
141 : ((((Size) 1) << ALLOC_MINBITS) << (fidx))
142 :
143 : /*
144 : * AllocSetContext is our standard implementation of MemoryContext.
145 : *
146 : * Note: header.isReset means there is nothing for AllocSetReset to do.
147 : * This is different from the aset being physically empty (empty blocks list)
148 : * because we will still have a keeper block. It's also different from the set
149 : * being logically empty, because we don't attempt to detect pfree'ing the
150 : * last active chunk.
151 : */
152 : typedef struct AllocSetContext
153 : {
154 : MemoryContextData header; /* Standard memory-context fields */
155 : /* Info about storage allocated in this context: */
156 : AllocBlock blocks; /* head of list of blocks in this set */
157 : MemoryChunk *freelist[ALLOCSET_NUM_FREELISTS]; /* free chunk lists */
158 : /* Allocation parameters for this context: */
159 : uint32 initBlockSize; /* initial block size */
160 : uint32 maxBlockSize; /* maximum block size */
161 : uint32 nextBlockSize; /* next block size to allocate */
162 : uint32 allocChunkLimit; /* effective chunk size limit */
163 : /* freelist this context could be put in, or -1 if not a candidate: */
164 : int freeListIndex; /* index in context_freelists[], or -1 */
165 : } AllocSetContext;
166 :
167 : typedef AllocSetContext *AllocSet;
168 :
169 : /*
170 : * AllocBlock
171 : * An AllocBlock is the unit of memory that is obtained by aset.c
172 : * from malloc(). It contains one or more MemoryChunks, which are
173 : * the units requested by palloc() and freed by pfree(). MemoryChunks
174 : * cannot be returned to malloc() individually, instead they are put
175 : * on freelists by pfree() and re-used by the next palloc() that has
176 : * a matching request size.
177 : *
178 : * AllocBlockData is the header data for a block --- the usable space
179 : * within the block begins at the next alignment boundary.
180 : */
181 : typedef struct AllocBlockData
182 : {
183 : AllocSet aset; /* aset that owns this block */
184 : AllocBlock prev; /* prev block in aset's blocks list, if any */
185 : AllocBlock next; /* next block in aset's blocks list, if any */
186 : char *freeptr; /* start of free space in this block */
187 : char *endptr; /* end of space in this block */
188 : } AllocBlockData;
189 :
190 : /*
191 : * AllocPointerIsValid
192 : * True iff pointer is valid allocation pointer.
193 : */
194 : #define AllocPointerIsValid(pointer) PointerIsValid(pointer)
195 :
196 : /*
197 : * AllocSetIsValid
198 : * True iff set is valid allocation set.
199 : */
200 : #define AllocSetIsValid(set) \
201 : (PointerIsValid(set) && IsA(set, AllocSetContext))
202 :
203 : /*
204 : * AllocBlockIsValid
205 : * True iff block is valid block of allocation set.
206 : */
207 : #define AllocBlockIsValid(block) \
208 : (PointerIsValid(block) && AllocSetIsValid((block)->aset))
209 :
210 : /*
211 : * We always store external chunks on a dedicated block. This makes fetching
212 : * the block from an external chunk easy since it's always the first and only
213 : * chunk on the block.
214 : */
215 : #define ExternalChunkGetBlock(chunk) \
216 : (AllocBlock) ((char *) chunk - ALLOC_BLOCKHDRSZ)
217 :
218 : /*
219 : * Rather than repeatedly creating and deleting memory contexts, we keep some
220 : * freed contexts in freelists so that we can hand them out again with little
221 : * work. Before putting a context in a freelist, we reset it so that it has
222 : * only its initial malloc chunk and no others. To be a candidate for a
223 : * freelist, a context must have the same minContextSize/initBlockSize as
224 : * other contexts in the list; but its maxBlockSize is irrelevant since that
225 : * doesn't affect the size of the initial chunk.
226 : *
227 : * We currently provide one freelist for ALLOCSET_DEFAULT_SIZES contexts
228 : * and one for ALLOCSET_SMALL_SIZES contexts; the latter works for
229 : * ALLOCSET_START_SMALL_SIZES too, since only the maxBlockSize differs.
230 : *
231 : * Ordinarily, we re-use freelist contexts in last-in-first-out order, in
232 : * hopes of improving locality of reference. But if there get to be too
233 : * many contexts in the list, we'd prefer to drop the most-recently-created
234 : * contexts in hopes of keeping the process memory map compact.
235 : * We approximate that by simply deleting all existing entries when the list
236 : * overflows, on the assumption that queries that allocate a lot of contexts
237 : * will probably free them in more or less reverse order of allocation.
238 : *
239 : * Contexts in a freelist are chained via their nextchild pointers.
240 : */
241 : #define MAX_FREE_CONTEXTS 100 /* arbitrary limit on freelist length */
242 :
243 : /* Obtain the keeper block for an allocation set */
244 : #define KeeperBlock(set) \
245 : ((AllocBlock) (((char *) set) + MAXALIGN(sizeof(AllocSetContext))))
246 :
247 : /* Check if the block is the keeper block of the given allocation set */
248 : #define IsKeeperBlock(set, block) ((block) == (KeeperBlock(set)))
249 :
250 : typedef struct AllocSetFreeList
251 : {
252 : int num_free; /* current list length */
253 : AllocSetContext *first_free; /* list header */
254 : } AllocSetFreeList;
255 :
256 : /* context_freelists[0] is for default params, [1] for small params */
257 : static AllocSetFreeList context_freelists[2] =
258 : {
259 : {
260 : 0, NULL
261 : },
262 : {
263 : 0, NULL
264 : }
265 : };
266 :
267 :
268 : /* ----------
269 : * AllocSetFreeIndex -
270 : *
271 : * Depending on the size of an allocation compute which freechunk
272 : * list of the alloc set it belongs to. Caller must have verified
273 : * that size <= ALLOC_CHUNK_LIMIT.
274 : * ----------
275 : */
276 : static inline int
277 1183760980 : AllocSetFreeIndex(Size size)
278 : {
279 : int idx;
280 :
281 1183760980 : if (size > (1 << ALLOC_MINBITS))
282 : {
283 : /*----------
284 : * At this point we must compute ceil(log2(size >> ALLOC_MINBITS)).
285 : * This is the same as
286 : * pg_leftmost_one_pos32((size - 1) >> ALLOC_MINBITS) + 1
287 : * or equivalently
288 : * pg_leftmost_one_pos32(size - 1) - ALLOC_MINBITS + 1
289 : *
290 : * However, for platforms without intrinsic support, we duplicate the
291 : * logic here, allowing an additional optimization. It's reasonable
292 : * to assume that ALLOC_CHUNK_LIMIT fits in 16 bits, so we can unroll
293 : * the byte-at-a-time loop in pg_leftmost_one_pos32 and just handle
294 : * the last two bytes.
295 : *
296 : * Yes, this function is enough of a hot-spot to make it worth this
297 : * much trouble.
298 : *----------
299 : */
300 : #ifdef HAVE_BITSCAN_REVERSE
301 1040865672 : idx = pg_leftmost_one_pos32((uint32) size - 1) - ALLOC_MINBITS + 1;
302 : #else
303 : uint32 t,
304 : tsize;
305 :
306 : /* Statically assert that we only have a 16-bit input value. */
307 : StaticAssertDecl(ALLOC_CHUNK_LIMIT < (1 << 16),
308 : "ALLOC_CHUNK_LIMIT must be less than 64kB");
309 :
310 : tsize = size - 1;
311 : t = tsize >> 8;
312 : idx = t ? pg_leftmost_one_pos[t] + 8 : pg_leftmost_one_pos[tsize];
313 : idx -= ALLOC_MINBITS - 1;
314 : #endif
315 :
316 : Assert(idx < ALLOCSET_NUM_FREELISTS);
317 : }
318 : else
319 142895308 : idx = 0;
320 :
321 1183760980 : return idx;
322 : }
323 :
324 :
325 : /*
326 : * Public routines
327 : */
328 :
329 :
330 : /*
331 : * AllocSetContextCreateInternal
332 : * Create a new AllocSet context.
333 : *
334 : * parent: parent context, or NULL if top-level context
335 : * name: name of context (must be statically allocated)
336 : * minContextSize: minimum context size
337 : * initBlockSize: initial allocation block size
338 : * maxBlockSize: maximum allocation block size
339 : *
340 : * Most callers should abstract the context size parameters using a macro
341 : * such as ALLOCSET_DEFAULT_SIZES.
342 : *
343 : * Note: don't call this directly; go through the wrapper macro
344 : * AllocSetContextCreate.
345 : */
346 : MemoryContext
347 11688068 : AllocSetContextCreateInternal(MemoryContext parent,
348 : const char *name,
349 : Size minContextSize,
350 : Size initBlockSize,
351 : Size maxBlockSize)
352 : {
353 : int freeListIndex;
354 : Size firstBlockSize;
355 : AllocSet set;
356 : AllocBlock block;
357 :
358 : /* ensure MemoryChunk's size is properly maxaligned */
359 : StaticAssertDecl(ALLOC_CHUNKHDRSZ == MAXALIGN(ALLOC_CHUNKHDRSZ),
360 : "sizeof(MemoryChunk) is not maxaligned");
361 : /* check we have enough space to store the freelist link */
362 : StaticAssertDecl(sizeof(AllocFreeListLink) <= (1 << ALLOC_MINBITS),
363 : "sizeof(AllocFreeListLink) larger than minimum allocation size");
364 :
365 : /*
366 : * First, validate allocation parameters. Once these were regular runtime
367 : * tests and elog's, but in practice Asserts seem sufficient because
368 : * nobody varies their parameters at runtime. We somewhat arbitrarily
369 : * enforce a minimum 1K block size. We restrict the maximum block size to
370 : * MEMORYCHUNK_MAX_BLOCKOFFSET as MemoryChunks are limited to this in
371 : * regards to addressing the offset between the chunk and the block that
372 : * the chunk is stored on. We would be unable to store the offset between
373 : * the chunk and block for any chunks that were beyond
374 : * MEMORYCHUNK_MAX_BLOCKOFFSET bytes into the block if the block was to be
375 : * larger than this.
376 : */
377 : Assert(initBlockSize == MAXALIGN(initBlockSize) &&
378 : initBlockSize >= 1024);
379 : Assert(maxBlockSize == MAXALIGN(maxBlockSize) &&
380 : maxBlockSize >= initBlockSize &&
381 : AllocHugeSizeIsValid(maxBlockSize)); /* must be safe to double */
382 : Assert(minContextSize == 0 ||
383 : (minContextSize == MAXALIGN(minContextSize) &&
384 : minContextSize >= 1024 &&
385 : minContextSize <= maxBlockSize));
386 : Assert(maxBlockSize <= MEMORYCHUNK_MAX_BLOCKOFFSET);
387 :
388 : /*
389 : * Check whether the parameters match either available freelist. We do
390 : * not need to demand a match of maxBlockSize.
391 : */
392 11688068 : if (minContextSize == ALLOCSET_DEFAULT_MINSIZE &&
393 : initBlockSize == ALLOCSET_DEFAULT_INITSIZE)
394 7743986 : freeListIndex = 0;
395 3944082 : else if (minContextSize == ALLOCSET_SMALL_MINSIZE &&
396 : initBlockSize == ALLOCSET_SMALL_INITSIZE)
397 3912254 : freeListIndex = 1;
398 : else
399 31828 : freeListIndex = -1;
400 :
401 : /*
402 : * If a suitable freelist entry exists, just recycle that context.
403 : */
404 11688068 : if (freeListIndex >= 0)
405 : {
406 11656240 : AllocSetFreeList *freelist = &context_freelists[freeListIndex];
407 :
408 11656240 : if (freelist->first_free != NULL)
409 : {
410 : /* Remove entry from freelist */
411 8369804 : set = freelist->first_free;
412 8369804 : freelist->first_free = (AllocSet) set->header.nextchild;
413 8369804 : freelist->num_free--;
414 :
415 : /* Update its maxBlockSize; everything else should be OK */
416 8369804 : set->maxBlockSize = maxBlockSize;
417 :
418 : /* Reinitialize its header, installing correct name and parent */
419 8369804 : MemoryContextCreate((MemoryContext) set,
420 : T_AllocSetContext,
421 : MCTX_ASET_ID,
422 : parent,
423 : name);
424 :
425 8369804 : ((MemoryContext) set)->mem_allocated =
426 8369804 : KeeperBlock(set)->endptr - ((char *) set);
427 :
428 8369804 : return (MemoryContext) set;
429 : }
430 : }
431 :
432 : /* Determine size of initial block */
433 3318264 : firstBlockSize = MAXALIGN(sizeof(AllocSetContext)) +
434 : ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
435 3318264 : if (minContextSize != 0)
436 31828 : firstBlockSize = Max(firstBlockSize, minContextSize);
437 : else
438 3286436 : firstBlockSize = Max(firstBlockSize, initBlockSize);
439 :
440 : /*
441 : * Allocate the initial block. Unlike other aset.c blocks, it starts with
442 : * the context header and its block header follows that.
443 : */
444 3318264 : set = (AllocSet) malloc(firstBlockSize);
445 3318264 : if (set == NULL)
446 : {
447 0 : if (TopMemoryContext)
448 0 : MemoryContextStats(TopMemoryContext);
449 0 : ereport(ERROR,
450 : (errcode(ERRCODE_OUT_OF_MEMORY),
451 : errmsg("out of memory"),
452 : errdetail("Failed while creating memory context \"%s\".",
453 : name)));
454 : }
455 :
456 : /*
457 : * Avoid writing code that can fail between here and MemoryContextCreate;
458 : * we'd leak the header/initial block if we ereport in this stretch.
459 : */
460 :
461 : /* Fill in the initial block's block header */
462 3318264 : block = KeeperBlock(set);
463 3318264 : block->aset = set;
464 3318264 : block->freeptr = ((char *) block) + ALLOC_BLOCKHDRSZ;
465 3318264 : block->endptr = ((char *) set) + firstBlockSize;
466 3318264 : block->prev = NULL;
467 3318264 : block->next = NULL;
468 :
469 : /* Mark unallocated space NOACCESS; leave the block header alone. */
470 : VALGRIND_MAKE_MEM_NOACCESS(block->freeptr, block->endptr - block->freeptr);
471 :
472 : /* Remember block as part of block list */
473 3318264 : set->blocks = block;
474 :
475 : /* Finish filling in aset-specific parts of the context header */
476 39819168 : MemSetAligned(set->freelist, 0, sizeof(set->freelist));
477 :
478 3318264 : set->initBlockSize = (uint32) initBlockSize;
479 3318264 : set->maxBlockSize = (uint32) maxBlockSize;
480 3318264 : set->nextBlockSize = (uint32) initBlockSize;
481 3318264 : set->freeListIndex = freeListIndex;
482 :
483 : /*
484 : * Compute the allocation chunk size limit for this context. It can't be
485 : * more than ALLOC_CHUNK_LIMIT because of the fixed number of freelists.
486 : * If maxBlockSize is small then requests exceeding the maxBlockSize, or
487 : * even a significant fraction of it, should be treated as large chunks
488 : * too. For the typical case of maxBlockSize a power of 2, the chunk size
489 : * limit will be at most 1/8th maxBlockSize, so that given a stream of
490 : * requests that are all the maximum chunk size we will waste at most
491 : * 1/8th of the allocated space.
492 : *
493 : * Also, allocChunkLimit must not exceed ALLOCSET_SEPARATE_THRESHOLD.
494 : */
495 : StaticAssertStmt(ALLOC_CHUNK_LIMIT == ALLOCSET_SEPARATE_THRESHOLD,
496 : "ALLOC_CHUNK_LIMIT != ALLOCSET_SEPARATE_THRESHOLD");
497 :
498 : /*
499 : * Determine the maximum size that a chunk can be before we allocate an
500 : * entire AllocBlock dedicated for that chunk. We set the absolute limit
501 : * of that size as ALLOC_CHUNK_LIMIT but we reduce it further so that we
502 : * can fit about ALLOC_CHUNK_FRACTION chunks this size on a maximally
503 : * sized block. (We opt to keep allocChunkLimit a power-of-2 value
504 : * primarily for legacy reasons rather than calculating it so that exactly
505 : * ALLOC_CHUNK_FRACTION chunks fit on a maximally sized block.)
506 : */
507 3318264 : set->allocChunkLimit = ALLOC_CHUNK_LIMIT;
508 3318264 : while ((Size) (set->allocChunkLimit + ALLOC_CHUNKHDRSZ) >
509 10985976 : (Size) ((maxBlockSize - ALLOC_BLOCKHDRSZ) / ALLOC_CHUNK_FRACTION))
510 7667712 : set->allocChunkLimit >>= 1;
511 :
512 : /* Finally, do the type-independent part of context creation */
513 3318264 : MemoryContextCreate((MemoryContext) set,
514 : T_AllocSetContext,
515 : MCTX_ASET_ID,
516 : parent,
517 : name);
518 :
519 3318264 : ((MemoryContext) set)->mem_allocated = firstBlockSize;
520 :
521 3318264 : return (MemoryContext) set;
522 : }
523 :
524 : /*
525 : * AllocSetReset
526 : * Frees all memory which is allocated in the given set.
527 : *
528 : * Actually, this routine has some discretion about what to do.
529 : * It should mark all allocated chunks freed, but it need not necessarily
530 : * give back all the resources the set owns. Our actual implementation is
531 : * that we give back all but the "keeper" block (which we must keep, since
532 : * it shares a malloc chunk with the context header). In this way, we don't
533 : * thrash malloc() when a context is repeatedly reset after small allocations,
534 : * which is typical behavior for per-tuple contexts.
535 : */
536 : void
537 48304146 : AllocSetReset(MemoryContext context)
538 : {
539 48304146 : AllocSet set = (AllocSet) context;
540 : AllocBlock block;
541 : Size keepersize PG_USED_FOR_ASSERTS_ONLY;
542 :
543 : Assert(AllocSetIsValid(set));
544 :
545 : #ifdef MEMORY_CONTEXT_CHECKING
546 : /* Check for corruption and leaks before freeing */
547 : AllocSetCheck(context);
548 : #endif
549 :
550 : /* Remember keeper block size for Assert below */
551 48304146 : keepersize = KeeperBlock(set)->endptr - ((char *) set);
552 :
553 : /* Clear chunk freelists */
554 579649752 : MemSetAligned(set->freelist, 0, sizeof(set->freelist));
555 :
556 48304146 : block = set->blocks;
557 :
558 : /* New blocks list will be just the keeper block */
559 48304146 : set->blocks = KeeperBlock(set);
560 :
561 106220444 : while (block != NULL)
562 : {
563 57916298 : AllocBlock next = block->next;
564 :
565 57916298 : if (IsKeeperBlock(set, block))
566 : {
567 : /* Reset the block, but don't return it to malloc */
568 48304146 : char *datastart = ((char *) block) + ALLOC_BLOCKHDRSZ;
569 :
570 : #ifdef CLOBBER_FREED_MEMORY
571 : wipe_mem(datastart, block->freeptr - datastart);
572 : #else
573 : /* wipe_mem() would have done this */
574 : VALGRIND_MAKE_MEM_NOACCESS(datastart, block->freeptr - datastart);
575 : #endif
576 48304146 : block->freeptr = datastart;
577 48304146 : block->prev = NULL;
578 48304146 : block->next = NULL;
579 : }
580 : else
581 : {
582 : /* Normal case, release the block */
583 9612152 : context->mem_allocated -= block->endptr - ((char *) block);
584 :
585 : #ifdef CLOBBER_FREED_MEMORY
586 : wipe_mem(block, block->freeptr - ((char *) block));
587 : #endif
588 9612152 : free(block);
589 : }
590 57916298 : block = next;
591 : }
592 :
593 : Assert(context->mem_allocated == keepersize);
594 :
595 : /* Reset block size allocation sequence, too */
596 48304146 : set->nextBlockSize = set->initBlockSize;
597 48304146 : }
598 :
599 : /*
600 : * AllocSetDelete
601 : * Frees all memory which is allocated in the given set,
602 : * in preparation for deletion of the set.
603 : *
604 : * Unlike AllocSetReset, this *must* free all resources of the set.
605 : */
606 : void
607 8803114 : AllocSetDelete(MemoryContext context)
608 : {
609 8803114 : AllocSet set = (AllocSet) context;
610 8803114 : AllocBlock block = set->blocks;
611 : Size keepersize PG_USED_FOR_ASSERTS_ONLY;
612 :
613 : Assert(AllocSetIsValid(set));
614 :
615 : #ifdef MEMORY_CONTEXT_CHECKING
616 : /* Check for corruption and leaks before freeing */
617 : AllocSetCheck(context);
618 : #endif
619 :
620 : /* Remember keeper block size for Assert below */
621 8803114 : keepersize = KeeperBlock(set)->endptr - ((char *) set);
622 :
623 : /*
624 : * If the context is a candidate for a freelist, put it into that freelist
625 : * instead of destroying it.
626 : */
627 8803114 : if (set->freeListIndex >= 0)
628 : {
629 8803114 : AllocSetFreeList *freelist = &context_freelists[set->freeListIndex];
630 :
631 : /*
632 : * Reset the context, if it needs it, so that we aren't hanging on to
633 : * more than the initial malloc chunk.
634 : */
635 8803114 : if (!context->isReset)
636 5371428 : MemoryContextResetOnly(context);
637 :
638 : /*
639 : * If the freelist is full, just discard what's already in it. See
640 : * comments with context_freelists[].
641 : */
642 8803114 : if (freelist->num_free >= MAX_FREE_CONTEXTS)
643 : {
644 61812 : while (freelist->first_free != NULL)
645 : {
646 61200 : AllocSetContext *oldset = freelist->first_free;
647 :
648 61200 : freelist->first_free = (AllocSetContext *) oldset->header.nextchild;
649 61200 : freelist->num_free--;
650 :
651 : /* All that remains is to free the header/initial block */
652 61200 : free(oldset);
653 : }
654 : Assert(freelist->num_free == 0);
655 : }
656 :
657 : /* Now add the just-deleted context to the freelist. */
658 8803114 : set->header.nextchild = (MemoryContext) freelist->first_free;
659 8803114 : freelist->first_free = set;
660 8803114 : freelist->num_free++;
661 :
662 8803114 : return;
663 : }
664 :
665 : /* Free all blocks, except the keeper which is part of context header */
666 0 : while (block != NULL)
667 : {
668 0 : AllocBlock next = block->next;
669 :
670 0 : if (!IsKeeperBlock(set, block))
671 0 : context->mem_allocated -= block->endptr - ((char *) block);
672 :
673 : #ifdef CLOBBER_FREED_MEMORY
674 : wipe_mem(block, block->freeptr - ((char *) block));
675 : #endif
676 :
677 0 : if (!IsKeeperBlock(set, block))
678 0 : free(block);
679 :
680 0 : block = next;
681 : }
682 :
683 : Assert(context->mem_allocated == keepersize);
684 :
685 : /* Finally, free the context header, including the keeper block */
686 0 : free(set);
687 : }
688 :
689 : /*
690 : * Helper for AllocSetAlloc() that allocates an entire block for the chunk.
691 : *
692 : * AllocSetAlloc()'s comment explains why this is separate.
693 : */
694 : pg_noinline
695 : static void *
696 17364406 : AllocSetAllocLarge(MemoryContext context, Size size, int flags)
697 : {
698 17364406 : AllocSet set = (AllocSet) context;
699 : AllocBlock block;
700 : MemoryChunk *chunk;
701 : Size chunk_size;
702 : Size blksize;
703 :
704 : /* validate 'size' is within the limits for the given 'flags' */
705 17364406 : MemoryContextCheckSize(context, size, flags);
706 :
707 : #ifdef MEMORY_CONTEXT_CHECKING
708 : /* ensure there's always space for the sentinel byte */
709 : chunk_size = MAXALIGN(size + 1);
710 : #else
711 17364406 : chunk_size = MAXALIGN(size);
712 : #endif
713 :
714 17364406 : blksize = chunk_size + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
715 17364406 : block = (AllocBlock) malloc(blksize);
716 17364406 : if (block == NULL)
717 0 : return MemoryContextAllocationFailure(context, size, flags);
718 :
719 17364406 : context->mem_allocated += blksize;
720 :
721 17364406 : block->aset = set;
722 17364406 : block->freeptr = block->endptr = ((char *) block) + blksize;
723 :
724 17364406 : chunk = (MemoryChunk *) (((char *) block) + ALLOC_BLOCKHDRSZ);
725 :
726 : /* mark the MemoryChunk as externally managed */
727 17364406 : MemoryChunkSetHdrMaskExternal(chunk, MCTX_ASET_ID);
728 :
729 : #ifdef MEMORY_CONTEXT_CHECKING
730 : chunk->requested_size = size;
731 : /* set mark to catch clobber of "unused" space */
732 : Assert(size < chunk_size);
733 : set_sentinel(MemoryChunkGetPointer(chunk), size);
734 : #endif
735 : #ifdef RANDOMIZE_ALLOCATED_MEMORY
736 : /* fill the allocated space with junk */
737 : randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
738 : #endif
739 :
740 : /*
741 : * Stick the new block underneath the active allocation block, if any, so
742 : * that we don't lose the use of the space remaining therein.
743 : */
744 17364406 : if (set->blocks != NULL)
745 : {
746 17364406 : block->prev = set->blocks;
747 17364406 : block->next = set->blocks->next;
748 17364406 : if (block->next)
749 14242736 : block->next->prev = block;
750 17364406 : set->blocks->next = block;
751 : }
752 : else
753 : {
754 0 : block->prev = NULL;
755 0 : block->next = NULL;
756 0 : set->blocks = block;
757 : }
758 :
759 : /* Ensure any padding bytes are marked NOACCESS. */
760 : VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
761 : chunk_size - size);
762 :
763 : /* Disallow access to the chunk header. */
764 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
765 :
766 17364406 : return MemoryChunkGetPointer(chunk);
767 : }
768 :
769 : /*
770 : * Small helper for allocating a new chunk from a chunk, to avoid duplicating
771 : * the code between AllocSetAlloc() and AllocSetAllocFromNewBlock().
772 : */
773 : static inline void *
774 826637194 : AllocSetAllocChunkFromBlock(MemoryContext context, AllocBlock block,
775 : Size size, Size chunk_size, int fidx)
776 : {
777 : MemoryChunk *chunk;
778 :
779 826637194 : chunk = (MemoryChunk *) (block->freeptr);
780 :
781 : /* Prepare to initialize the chunk header. */
782 : VALGRIND_MAKE_MEM_UNDEFINED(chunk, ALLOC_CHUNKHDRSZ);
783 :
784 826637194 : block->freeptr += (chunk_size + ALLOC_CHUNKHDRSZ);
785 : Assert(block->freeptr <= block->endptr);
786 :
787 : /* store the free list index in the value field */
788 826637194 : MemoryChunkSetHdrMask(chunk, block, fidx, MCTX_ASET_ID);
789 :
790 : #ifdef MEMORY_CONTEXT_CHECKING
791 : chunk->requested_size = size;
792 : /* set mark to catch clobber of "unused" space */
793 : if (size < chunk_size)
794 : set_sentinel(MemoryChunkGetPointer(chunk), size);
795 : #endif
796 : #ifdef RANDOMIZE_ALLOCATED_MEMORY
797 : /* fill the allocated space with junk */
798 : randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
799 : #endif
800 :
801 : /* Ensure any padding bytes are marked NOACCESS. */
802 : VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
803 : chunk_size - size);
804 :
805 : /* Disallow access to the chunk header. */
806 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
807 :
808 826637194 : return MemoryChunkGetPointer(chunk);
809 : }
810 :
811 : /*
812 : * Helper for AllocSetAlloc() that allocates a new block and returns a chunk
813 : * allocated from it.
814 : *
815 : * AllocSetAlloc()'s comment explains why this is separate.
816 : */
817 : pg_noinline
818 : static void *
819 10310680 : AllocSetAllocFromNewBlock(MemoryContext context, Size size, int flags,
820 : int fidx)
821 : {
822 10310680 : AllocSet set = (AllocSet) context;
823 : AllocBlock block;
824 : Size availspace;
825 : Size blksize;
826 : Size required_size;
827 : Size chunk_size;
828 :
829 : /* due to the keeper block set->blocks should always be valid */
830 : Assert(set->blocks != NULL);
831 10310680 : block = set->blocks;
832 10310680 : availspace = block->endptr - block->freeptr;
833 :
834 : /*
835 : * The existing active (top) block does not have enough room for the
836 : * requested allocation, but it might still have a useful amount of space
837 : * in it. Once we push it down in the block list, we'll never try to
838 : * allocate more space from it. So, before we do that, carve up its free
839 : * space into chunks that we can put on the set's freelists.
840 : *
841 : * Because we can only get here when there's less than ALLOC_CHUNK_LIMIT
842 : * left in the block, this loop cannot iterate more than
843 : * ALLOCSET_NUM_FREELISTS-1 times.
844 : */
845 40280660 : while (availspace >= ((1 << ALLOC_MINBITS) + ALLOC_CHUNKHDRSZ))
846 : {
847 : AllocFreeListLink *link;
848 : MemoryChunk *chunk;
849 29969980 : Size availchunk = availspace - ALLOC_CHUNKHDRSZ;
850 29969980 : int a_fidx = AllocSetFreeIndex(availchunk);
851 :
852 : /*
853 : * In most cases, we'll get back the index of the next larger freelist
854 : * than the one we need to put this chunk on. The exception is when
855 : * availchunk is exactly a power of 2.
856 : */
857 29969980 : if (availchunk != GetChunkSizeFromFreeListIdx(a_fidx))
858 : {
859 22310604 : a_fidx--;
860 : Assert(a_fidx >= 0);
861 22310604 : availchunk = GetChunkSizeFromFreeListIdx(a_fidx);
862 : }
863 :
864 29969980 : chunk = (MemoryChunk *) (block->freeptr);
865 :
866 : /* Prepare to initialize the chunk header. */
867 : VALGRIND_MAKE_MEM_UNDEFINED(chunk, ALLOC_CHUNKHDRSZ);
868 29969980 : block->freeptr += (availchunk + ALLOC_CHUNKHDRSZ);
869 29969980 : availspace -= (availchunk + ALLOC_CHUNKHDRSZ);
870 :
871 : /* store the freelist index in the value field */
872 29969980 : MemoryChunkSetHdrMask(chunk, block, a_fidx, MCTX_ASET_ID);
873 : #ifdef MEMORY_CONTEXT_CHECKING
874 : chunk->requested_size = InvalidAllocSize; /* mark it free */
875 : #endif
876 : /* push this chunk onto the free list */
877 29969980 : link = GetFreeListLink(chunk);
878 :
879 : VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
880 29969980 : link->next = set->freelist[a_fidx];
881 : VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
882 :
883 29969980 : set->freelist[a_fidx] = chunk;
884 : }
885 :
886 : /*
887 : * The first such block has size initBlockSize, and we double the space in
888 : * each succeeding block, but not more than maxBlockSize.
889 : */
890 10310680 : blksize = set->nextBlockSize;
891 10310680 : set->nextBlockSize <<= 1;
892 10310680 : if (set->nextBlockSize > set->maxBlockSize)
893 734784 : set->nextBlockSize = set->maxBlockSize;
894 :
895 : /* Choose the actual chunk size to allocate */
896 10310680 : chunk_size = GetChunkSizeFromFreeListIdx(fidx);
897 : Assert(chunk_size >= size);
898 :
899 : /*
900 : * If initBlockSize is less than ALLOC_CHUNK_LIMIT, we could need more
901 : * space... but try to keep it a power of 2.
902 : */
903 10310680 : required_size = chunk_size + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
904 14804642 : while (blksize < required_size)
905 4493962 : blksize <<= 1;
906 :
907 : /* Try to allocate it */
908 10310680 : block = (AllocBlock) malloc(blksize);
909 :
910 : /*
911 : * We could be asking for pretty big blocks here, so cope if malloc fails.
912 : * But give up if there's less than 1 MB or so available...
913 : */
914 10310680 : while (block == NULL && blksize > 1024 * 1024)
915 : {
916 0 : blksize >>= 1;
917 0 : if (blksize < required_size)
918 0 : break;
919 0 : block = (AllocBlock) malloc(blksize);
920 : }
921 :
922 10310680 : if (block == NULL)
923 0 : return MemoryContextAllocationFailure(context, size, flags);
924 :
925 10310680 : context->mem_allocated += blksize;
926 :
927 10310680 : block->aset = set;
928 10310680 : block->freeptr = ((char *) block) + ALLOC_BLOCKHDRSZ;
929 10310680 : block->endptr = ((char *) block) + blksize;
930 :
931 : /* Mark unallocated space NOACCESS. */
932 : VALGRIND_MAKE_MEM_NOACCESS(block->freeptr,
933 : blksize - ALLOC_BLOCKHDRSZ);
934 :
935 10310680 : block->prev = NULL;
936 10310680 : block->next = set->blocks;
937 10310680 : if (block->next)
938 10310680 : block->next->prev = block;
939 10310680 : set->blocks = block;
940 :
941 10310680 : return AllocSetAllocChunkFromBlock(context, block, size, chunk_size, fidx);
942 : }
943 :
944 : /*
945 : * AllocSetAlloc
946 : * Returns a pointer to allocated memory of given size or raises an ERROR
947 : * on allocation failure, or returns NULL when flags contains
948 : * MCXT_ALLOC_NO_OOM.
949 : *
950 : * No request may exceed:
951 : * MAXALIGN_DOWN(SIZE_MAX) - ALLOC_BLOCKHDRSZ - ALLOC_CHUNKHDRSZ
952 : * All callers use a much-lower limit.
953 : *
954 : * Note: when using valgrind, it doesn't matter how the returned allocation
955 : * is marked, as mcxt.c will set it to UNDEFINED. In some paths we will
956 : * return space that is marked NOACCESS - AllocSetRealloc has to beware!
957 : *
958 : * This function should only contain the most common code paths. Everything
959 : * else should be in pg_noinline helper functions, thus avoiding the overhead
960 : * of creating a stack frame for the common cases. Allocating memory is often
961 : * a bottleneck in many workloads, so avoiding stack frame setup is
962 : * worthwhile. Helper functions should always directly return the newly
963 : * allocated memory so that we can just return that address directly as a tail
964 : * call.
965 : */
966 : void *
967 1171155406 : AllocSetAlloc(MemoryContext context, Size size, int flags)
968 : {
969 1171155406 : AllocSet set = (AllocSet) context;
970 : AllocBlock block;
971 : MemoryChunk *chunk;
972 : int fidx;
973 : Size chunk_size;
974 : Size availspace;
975 :
976 : Assert(AllocSetIsValid(set));
977 :
978 : /* due to the keeper block set->blocks should never be NULL */
979 : Assert(set->blocks != NULL);
980 :
981 : /*
982 : * If requested size exceeds maximum for chunks we hand the request off to
983 : * AllocSetAllocLarge().
984 : */
985 1171155406 : if (size > set->allocChunkLimit)
986 17364406 : return AllocSetAllocLarge(context, size, flags);
987 :
988 : /*
989 : * Request is small enough to be treated as a chunk. Look in the
990 : * corresponding free list to see if there is a free chunk we could reuse.
991 : * If one is found, remove it from the free list, make it again a member
992 : * of the alloc set and return its data address.
993 : *
994 : * Note that we don't attempt to ensure there's space for the sentinel
995 : * byte here. We expect a large proportion of allocations to be for sizes
996 : * which are already a power of 2. If we were to always make space for a
997 : * sentinel byte in MEMORY_CONTEXT_CHECKING builds, then we'd end up
998 : * doubling the memory requirements for such allocations.
999 : */
1000 1153791000 : fidx = AllocSetFreeIndex(size);
1001 1153791000 : chunk = set->freelist[fidx];
1002 1153791000 : if (chunk != NULL)
1003 : {
1004 327153806 : AllocFreeListLink *link = GetFreeListLink(chunk);
1005 :
1006 : /* Allow access to the chunk header. */
1007 : VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
1008 :
1009 : Assert(fidx == MemoryChunkGetValue(chunk));
1010 :
1011 : /* pop this chunk off the freelist */
1012 : VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
1013 327153806 : set->freelist[fidx] = link->next;
1014 : VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
1015 :
1016 : #ifdef MEMORY_CONTEXT_CHECKING
1017 : chunk->requested_size = size;
1018 : /* set mark to catch clobber of "unused" space */
1019 : if (size < GetChunkSizeFromFreeListIdx(fidx))
1020 : set_sentinel(MemoryChunkGetPointer(chunk), size);
1021 : #endif
1022 : #ifdef RANDOMIZE_ALLOCATED_MEMORY
1023 : /* fill the allocated space with junk */
1024 : randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
1025 : #endif
1026 :
1027 : /* Ensure any padding bytes are marked NOACCESS. */
1028 : VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
1029 : GetChunkSizeFromFreeListIdx(fidx) - size);
1030 :
1031 : /* Disallow access to the chunk header. */
1032 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1033 :
1034 327153806 : return MemoryChunkGetPointer(chunk);
1035 : }
1036 :
1037 : /*
1038 : * Choose the actual chunk size to allocate.
1039 : */
1040 826637194 : chunk_size = GetChunkSizeFromFreeListIdx(fidx);
1041 : Assert(chunk_size >= size);
1042 :
1043 826637194 : block = set->blocks;
1044 826637194 : availspace = block->endptr - block->freeptr;
1045 :
1046 : /*
1047 : * If there is enough room in the active allocation block, we will put the
1048 : * chunk into that block. Else must start a new one.
1049 : */
1050 826637194 : if (unlikely(availspace < (chunk_size + ALLOC_CHUNKHDRSZ)))
1051 10310680 : return AllocSetAllocFromNewBlock(context, size, flags, fidx);
1052 :
1053 : /* There's enough space on the current block, so allocate from that */
1054 816326514 : return AllocSetAllocChunkFromBlock(context, block, size, chunk_size, fidx);
1055 : }
1056 :
1057 : /*
1058 : * AllocSetFree
1059 : * Frees allocated memory; memory is removed from the set.
1060 : */
1061 : void
1062 407213658 : AllocSetFree(void *pointer)
1063 : {
1064 : AllocSet set;
1065 407213658 : MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
1066 :
1067 : /* Allow access to the chunk header. */
1068 : VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
1069 :
1070 407213658 : if (MemoryChunkIsExternal(chunk))
1071 : {
1072 : /* Release single-chunk block. */
1073 16188558 : AllocBlock block = ExternalChunkGetBlock(chunk);
1074 :
1075 : /*
1076 : * Try to verify that we have a sane block pointer: the block header
1077 : * should reference an aset and the freeptr should match the endptr.
1078 : */
1079 16188558 : if (!AllocBlockIsValid(block) || block->freeptr != block->endptr)
1080 0 : elog(ERROR, "could not find block containing chunk %p", chunk);
1081 :
1082 16188558 : set = block->aset;
1083 :
1084 : #ifdef MEMORY_CONTEXT_CHECKING
1085 : {
1086 : /* Test for someone scribbling on unused space in chunk */
1087 : Assert(chunk->requested_size < (block->endptr - (char *) pointer));
1088 : if (!sentinel_ok(pointer, chunk->requested_size))
1089 : elog(WARNING, "detected write past chunk end in %s %p",
1090 : set->header.name, chunk);
1091 : }
1092 : #endif
1093 :
1094 : /* OK, remove block from aset's list and free it */
1095 16188558 : if (block->prev)
1096 16188558 : block->prev->next = block->next;
1097 : else
1098 0 : set->blocks = block->next;
1099 16188558 : if (block->next)
1100 13256662 : block->next->prev = block->prev;
1101 :
1102 16188558 : set->header.mem_allocated -= block->endptr - ((char *) block);
1103 :
1104 : #ifdef CLOBBER_FREED_MEMORY
1105 : wipe_mem(block, block->freeptr - ((char *) block));
1106 : #endif
1107 16188558 : free(block);
1108 : }
1109 : else
1110 : {
1111 391025100 : AllocBlock block = MemoryChunkGetBlock(chunk);
1112 : int fidx;
1113 : AllocFreeListLink *link;
1114 :
1115 : /*
1116 : * In this path, for speed reasons we just Assert that the referenced
1117 : * block is good. We can also Assert that the value field is sane.
1118 : * Future field experience may show that these Asserts had better
1119 : * become regular runtime test-and-elog checks.
1120 : */
1121 : Assert(AllocBlockIsValid(block));
1122 391025100 : set = block->aset;
1123 :
1124 391025100 : fidx = MemoryChunkGetValue(chunk);
1125 : Assert(FreeListIdxIsValid(fidx));
1126 391025100 : link = GetFreeListLink(chunk);
1127 :
1128 : #ifdef MEMORY_CONTEXT_CHECKING
1129 : /* Test for someone scribbling on unused space in chunk */
1130 : if (chunk->requested_size < GetChunkSizeFromFreeListIdx(fidx))
1131 : if (!sentinel_ok(pointer, chunk->requested_size))
1132 : elog(WARNING, "detected write past chunk end in %s %p",
1133 : set->header.name, chunk);
1134 : #endif
1135 :
1136 : #ifdef CLOBBER_FREED_MEMORY
1137 : wipe_mem(pointer, GetChunkSizeFromFreeListIdx(fidx));
1138 : #endif
1139 : /* push this chunk onto the top of the free list */
1140 : VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
1141 391025100 : link->next = set->freelist[fidx];
1142 : VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
1143 391025100 : set->freelist[fidx] = chunk;
1144 :
1145 : #ifdef MEMORY_CONTEXT_CHECKING
1146 :
1147 : /*
1148 : * Reset requested_size to InvalidAllocSize in chunks that are on free
1149 : * list.
1150 : */
1151 : chunk->requested_size = InvalidAllocSize;
1152 : #endif
1153 : }
1154 407213658 : }
1155 :
1156 : /*
1157 : * AllocSetRealloc
1158 : * Returns new pointer to allocated memory of given size or NULL if
1159 : * request could not be completed; this memory is added to the set.
1160 : * Memory associated with given pointer is copied into the new memory,
1161 : * and the old memory is freed.
1162 : *
1163 : * Without MEMORY_CONTEXT_CHECKING, we don't know the old request size. This
1164 : * makes our Valgrind client requests less-precise, hazarding false negatives.
1165 : * (In principle, we could use VALGRIND_GET_VBITS() to rediscover the old
1166 : * request size.)
1167 : */
1168 : void *
1169 8184786 : AllocSetRealloc(void *pointer, Size size, int flags)
1170 : {
1171 : AllocBlock block;
1172 : AllocSet set;
1173 8184786 : MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
1174 : Size oldchksize;
1175 : int fidx;
1176 :
1177 : /* Allow access to the chunk header. */
1178 : VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
1179 :
1180 8184786 : if (MemoryChunkIsExternal(chunk))
1181 : {
1182 : /*
1183 : * The chunk must have been allocated as a single-chunk block. Use
1184 : * realloc() to make the containing block bigger, or smaller, with
1185 : * minimum space wastage.
1186 : */
1187 : Size chksize;
1188 : Size blksize;
1189 : Size oldblksize;
1190 :
1191 212180 : block = ExternalChunkGetBlock(chunk);
1192 :
1193 : /*
1194 : * Try to verify that we have a sane block pointer: the block header
1195 : * should reference an aset and the freeptr should match the endptr.
1196 : */
1197 212180 : if (!AllocBlockIsValid(block) || block->freeptr != block->endptr)
1198 0 : elog(ERROR, "could not find block containing chunk %p", chunk);
1199 :
1200 212180 : set = block->aset;
1201 :
1202 : /* only check size in paths where the limits could be hit */
1203 212180 : MemoryContextCheckSize((MemoryContext) set, size, flags);
1204 :
1205 212180 : oldchksize = block->endptr - (char *) pointer;
1206 :
1207 : #ifdef MEMORY_CONTEXT_CHECKING
1208 : /* Test for someone scribbling on unused space in chunk */
1209 : Assert(chunk->requested_size < oldchksize);
1210 : if (!sentinel_ok(pointer, chunk->requested_size))
1211 : elog(WARNING, "detected write past chunk end in %s %p",
1212 : set->header.name, chunk);
1213 : #endif
1214 :
1215 : #ifdef MEMORY_CONTEXT_CHECKING
1216 : /* ensure there's always space for the sentinel byte */
1217 : chksize = MAXALIGN(size + 1);
1218 : #else
1219 212180 : chksize = MAXALIGN(size);
1220 : #endif
1221 :
1222 : /* Do the realloc */
1223 212180 : blksize = chksize + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
1224 212180 : oldblksize = block->endptr - ((char *) block);
1225 :
1226 212180 : block = (AllocBlock) realloc(block, blksize);
1227 212180 : if (block == NULL)
1228 : {
1229 : /* Disallow access to the chunk header. */
1230 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1231 0 : return MemoryContextAllocationFailure(&set->header, size, flags);
1232 : }
1233 :
1234 : /* updated separately, not to underflow when (oldblksize > blksize) */
1235 212180 : set->header.mem_allocated -= oldblksize;
1236 212180 : set->header.mem_allocated += blksize;
1237 :
1238 212180 : block->freeptr = block->endptr = ((char *) block) + blksize;
1239 :
1240 : /* Update pointers since block has likely been moved */
1241 212180 : chunk = (MemoryChunk *) (((char *) block) + ALLOC_BLOCKHDRSZ);
1242 212180 : pointer = MemoryChunkGetPointer(chunk);
1243 212180 : if (block->prev)
1244 212180 : block->prev->next = block;
1245 : else
1246 0 : set->blocks = block;
1247 212180 : if (block->next)
1248 189116 : block->next->prev = block;
1249 :
1250 : #ifdef MEMORY_CONTEXT_CHECKING
1251 : #ifdef RANDOMIZE_ALLOCATED_MEMORY
1252 :
1253 : /*
1254 : * We can only randomize the extra space if we know the prior request.
1255 : * When using Valgrind, randomize_mem() also marks memory UNDEFINED.
1256 : */
1257 : if (size > chunk->requested_size)
1258 : randomize_mem((char *) pointer + chunk->requested_size,
1259 : size - chunk->requested_size);
1260 : #else
1261 :
1262 : /*
1263 : * If this is an increase, realloc() will have marked any
1264 : * newly-allocated part (from oldchksize to chksize) UNDEFINED, but we
1265 : * also need to adjust trailing bytes from the old allocation (from
1266 : * chunk->requested_size to oldchksize) as they are marked NOACCESS.
1267 : * Make sure not to mark too many bytes in case chunk->requested_size
1268 : * < size < oldchksize.
1269 : */
1270 : #ifdef USE_VALGRIND
1271 : if (Min(size, oldchksize) > chunk->requested_size)
1272 : VALGRIND_MAKE_MEM_UNDEFINED((char *) pointer + chunk->requested_size,
1273 : Min(size, oldchksize) - chunk->requested_size);
1274 : #endif
1275 : #endif
1276 :
1277 : chunk->requested_size = size;
1278 : /* set mark to catch clobber of "unused" space */
1279 : Assert(size < chksize);
1280 : set_sentinel(pointer, size);
1281 : #else /* !MEMORY_CONTEXT_CHECKING */
1282 :
1283 : /*
1284 : * We may need to adjust marking of bytes from the old allocation as
1285 : * some of them may be marked NOACCESS. We don't know how much of the
1286 : * old chunk size was the requested size; it could have been as small
1287 : * as one byte. We have to be conservative and just mark the entire
1288 : * old portion DEFINED. Make sure not to mark memory beyond the new
1289 : * allocation in case it's smaller than the old one.
1290 : */
1291 : VALGRIND_MAKE_MEM_DEFINED(pointer, Min(size, oldchksize));
1292 : #endif
1293 :
1294 : /* Ensure any padding bytes are marked NOACCESS. */
1295 : VALGRIND_MAKE_MEM_NOACCESS((char *) pointer + size, chksize - size);
1296 :
1297 : /* Disallow access to the chunk header . */
1298 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1299 :
1300 212180 : return pointer;
1301 : }
1302 :
1303 7972606 : block = MemoryChunkGetBlock(chunk);
1304 :
1305 : /*
1306 : * In this path, for speed reasons we just Assert that the referenced
1307 : * block is good. We can also Assert that the value field is sane. Future
1308 : * field experience may show that these Asserts had better become regular
1309 : * runtime test-and-elog checks.
1310 : */
1311 : Assert(AllocBlockIsValid(block));
1312 7972606 : set = block->aset;
1313 :
1314 7972606 : fidx = MemoryChunkGetValue(chunk);
1315 : Assert(FreeListIdxIsValid(fidx));
1316 7972606 : oldchksize = GetChunkSizeFromFreeListIdx(fidx);
1317 :
1318 : #ifdef MEMORY_CONTEXT_CHECKING
1319 : /* Test for someone scribbling on unused space in chunk */
1320 : if (chunk->requested_size < oldchksize)
1321 : if (!sentinel_ok(pointer, chunk->requested_size))
1322 : elog(WARNING, "detected write past chunk end in %s %p",
1323 : set->header.name, chunk);
1324 : #endif
1325 :
1326 : /*
1327 : * Chunk sizes are aligned to power of 2 in AllocSetAlloc(). Maybe the
1328 : * allocated area already is >= the new size. (In particular, we will
1329 : * fall out here if the requested size is a decrease.)
1330 : */
1331 7972606 : if (oldchksize >= size)
1332 : {
1333 : #ifdef MEMORY_CONTEXT_CHECKING
1334 : Size oldrequest = chunk->requested_size;
1335 :
1336 : #ifdef RANDOMIZE_ALLOCATED_MEMORY
1337 : /* We can only fill the extra space if we know the prior request */
1338 : if (size > oldrequest)
1339 : randomize_mem((char *) pointer + oldrequest,
1340 : size - oldrequest);
1341 : #endif
1342 :
1343 : chunk->requested_size = size;
1344 :
1345 : /*
1346 : * If this is an increase, mark any newly-available part UNDEFINED.
1347 : * Otherwise, mark the obsolete part NOACCESS.
1348 : */
1349 : if (size > oldrequest)
1350 : VALGRIND_MAKE_MEM_UNDEFINED((char *) pointer + oldrequest,
1351 : size - oldrequest);
1352 : else
1353 : VALGRIND_MAKE_MEM_NOACCESS((char *) pointer + size,
1354 : oldchksize - size);
1355 :
1356 : /* set mark to catch clobber of "unused" space */
1357 : if (size < oldchksize)
1358 : set_sentinel(pointer, size);
1359 : #else /* !MEMORY_CONTEXT_CHECKING */
1360 :
1361 : /*
1362 : * We don't have the information to determine whether we're growing
1363 : * the old request or shrinking it, so we conservatively mark the
1364 : * entire new allocation DEFINED.
1365 : */
1366 : VALGRIND_MAKE_MEM_NOACCESS(pointer, oldchksize);
1367 : VALGRIND_MAKE_MEM_DEFINED(pointer, size);
1368 : #endif
1369 :
1370 : /* Disallow access to the chunk header. */
1371 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1372 :
1373 2557686 : return pointer;
1374 : }
1375 : else
1376 : {
1377 : /*
1378 : * Enlarge-a-small-chunk case. We just do this by brute force, ie,
1379 : * allocate a new chunk and copy the data. Since we know the existing
1380 : * data isn't huge, this won't involve any great memcpy expense, so
1381 : * it's not worth being smarter. (At one time we tried to avoid
1382 : * memcpy when it was possible to enlarge the chunk in-place, but that
1383 : * turns out to misbehave unpleasantly for repeated cycles of
1384 : * palloc/repalloc/pfree: the eventually freed chunks go into the
1385 : * wrong freelist for the next initial palloc request, and so we leak
1386 : * memory indefinitely. See pgsql-hackers archives for 2007-08-11.)
1387 : */
1388 : AllocPointer newPointer;
1389 : Size oldsize;
1390 :
1391 : /* allocate new chunk (this also checks size is valid) */
1392 5414920 : newPointer = AllocSetAlloc((MemoryContext) set, size, flags);
1393 :
1394 : /* leave immediately if request was not completed */
1395 5414920 : if (newPointer == NULL)
1396 : {
1397 : /* Disallow access to the chunk header. */
1398 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1399 0 : return MemoryContextAllocationFailure((MemoryContext) set, size, flags);
1400 : }
1401 :
1402 : /*
1403 : * AllocSetAlloc() may have returned a region that is still NOACCESS.
1404 : * Change it to UNDEFINED for the moment; memcpy() will then transfer
1405 : * definedness from the old allocation to the new. If we know the old
1406 : * allocation, copy just that much. Otherwise, make the entire old
1407 : * chunk defined to avoid errors as we copy the currently-NOACCESS
1408 : * trailing bytes.
1409 : */
1410 : VALGRIND_MAKE_MEM_UNDEFINED(newPointer, size);
1411 : #ifdef MEMORY_CONTEXT_CHECKING
1412 : oldsize = chunk->requested_size;
1413 : #else
1414 5414920 : oldsize = oldchksize;
1415 : VALGRIND_MAKE_MEM_DEFINED(pointer, oldsize);
1416 : #endif
1417 :
1418 : /* transfer existing data (certain to fit) */
1419 5414920 : memcpy(newPointer, pointer, oldsize);
1420 :
1421 : /* free old chunk */
1422 5414920 : AllocSetFree(pointer);
1423 :
1424 5414920 : return newPointer;
1425 : }
1426 : }
1427 :
1428 : /*
1429 : * AllocSetGetChunkContext
1430 : * Return the MemoryContext that 'pointer' belongs to.
1431 : */
1432 : MemoryContext
1433 3167656 : AllocSetGetChunkContext(void *pointer)
1434 : {
1435 3167656 : MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
1436 : AllocBlock block;
1437 : AllocSet set;
1438 :
1439 : /* Allow access to the chunk header. */
1440 : VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
1441 :
1442 3167656 : if (MemoryChunkIsExternal(chunk))
1443 0 : block = ExternalChunkGetBlock(chunk);
1444 : else
1445 3167656 : block = (AllocBlock) MemoryChunkGetBlock(chunk);
1446 :
1447 : /* Disallow access to the chunk header. */
1448 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1449 :
1450 : Assert(AllocBlockIsValid(block));
1451 3167656 : set = block->aset;
1452 :
1453 3167656 : return &set->header;
1454 : }
1455 :
1456 : /*
1457 : * AllocSetGetChunkSpace
1458 : * Given a currently-allocated chunk, determine the total space
1459 : * it occupies (including all memory-allocation overhead).
1460 : */
1461 : Size
1462 8876146 : AllocSetGetChunkSpace(void *pointer)
1463 : {
1464 8876146 : MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
1465 : int fidx;
1466 :
1467 : /* Allow access to the chunk header. */
1468 : VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
1469 :
1470 8876146 : if (MemoryChunkIsExternal(chunk))
1471 : {
1472 1091538 : AllocBlock block = ExternalChunkGetBlock(chunk);
1473 :
1474 : /* Disallow access to the chunk header. */
1475 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1476 :
1477 : Assert(AllocBlockIsValid(block));
1478 :
1479 1091538 : return block->endptr - (char *) chunk;
1480 : }
1481 :
1482 7784608 : fidx = MemoryChunkGetValue(chunk);
1483 : Assert(FreeListIdxIsValid(fidx));
1484 :
1485 : /* Disallow access to the chunk header. */
1486 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1487 :
1488 7784608 : return GetChunkSizeFromFreeListIdx(fidx) + ALLOC_CHUNKHDRSZ;
1489 : }
1490 :
1491 : /*
1492 : * AllocSetIsEmpty
1493 : * Is an allocset empty of any allocated space?
1494 : */
1495 : bool
1496 10730 : AllocSetIsEmpty(MemoryContext context)
1497 : {
1498 : Assert(AllocSetIsValid(context));
1499 :
1500 : /*
1501 : * For now, we say "empty" only if the context is new or just reset. We
1502 : * could examine the freelists to determine if all space has been freed,
1503 : * but it's not really worth the trouble for present uses of this
1504 : * functionality.
1505 : */
1506 10730 : if (context->isReset)
1507 10714 : return true;
1508 16 : return false;
1509 : }
1510 :
1511 : /*
1512 : * AllocSetStats
1513 : * Compute stats about memory consumption of an allocset.
1514 : *
1515 : * printfunc: if not NULL, pass a human-readable stats string to this.
1516 : * passthru: pass this pointer through to printfunc.
1517 : * totals: if not NULL, add stats about this context into *totals.
1518 : * print_to_stderr: print stats to stderr if true, elog otherwise.
1519 : */
1520 : void
1521 4734 : AllocSetStats(MemoryContext context,
1522 : MemoryStatsPrintFunc printfunc, void *passthru,
1523 : MemoryContextCounters *totals, bool print_to_stderr)
1524 : {
1525 4734 : AllocSet set = (AllocSet) context;
1526 4734 : Size nblocks = 0;
1527 4734 : Size freechunks = 0;
1528 : Size totalspace;
1529 4734 : Size freespace = 0;
1530 : AllocBlock block;
1531 : int fidx;
1532 :
1533 : Assert(AllocSetIsValid(set));
1534 :
1535 : /* Include context header in totalspace */
1536 4734 : totalspace = MAXALIGN(sizeof(AllocSetContext));
1537 :
1538 13118 : for (block = set->blocks; block != NULL; block = block->next)
1539 : {
1540 8384 : nblocks++;
1541 8384 : totalspace += block->endptr - ((char *) block);
1542 8384 : freespace += block->endptr - block->freeptr;
1543 : }
1544 56808 : for (fidx = 0; fidx < ALLOCSET_NUM_FREELISTS; fidx++)
1545 : {
1546 52074 : Size chksz = GetChunkSizeFromFreeListIdx(fidx);
1547 52074 : MemoryChunk *chunk = set->freelist[fidx];
1548 :
1549 67690 : while (chunk != NULL)
1550 : {
1551 15616 : AllocFreeListLink *link = GetFreeListLink(chunk);
1552 :
1553 : /* Allow access to the chunk header. */
1554 : VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
1555 : Assert(MemoryChunkGetValue(chunk) == fidx);
1556 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1557 :
1558 15616 : freechunks++;
1559 15616 : freespace += chksz + ALLOC_CHUNKHDRSZ;
1560 :
1561 : VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
1562 15616 : chunk = link->next;
1563 : VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
1564 : }
1565 : }
1566 :
1567 4734 : if (printfunc)
1568 : {
1569 : char stats_string[200];
1570 :
1571 1614 : snprintf(stats_string, sizeof(stats_string),
1572 : "%zu total in %zu blocks; %zu free (%zu chunks); %zu used",
1573 : totalspace, nblocks, freespace, freechunks,
1574 : totalspace - freespace);
1575 1614 : printfunc(context, passthru, stats_string, print_to_stderr);
1576 : }
1577 :
1578 4734 : if (totals)
1579 : {
1580 4734 : totals->nblocks += nblocks;
1581 4734 : totals->freechunks += freechunks;
1582 4734 : totals->totalspace += totalspace;
1583 4734 : totals->freespace += freespace;
1584 : }
1585 4734 : }
1586 :
1587 :
1588 : #ifdef MEMORY_CONTEXT_CHECKING
1589 :
1590 : /*
1591 : * AllocSetCheck
1592 : * Walk through chunks and check consistency of memory.
1593 : *
1594 : * NOTE: report errors as WARNING, *not* ERROR or FATAL. Otherwise you'll
1595 : * find yourself in an infinite loop when trouble occurs, because this
1596 : * routine will be entered again when elog cleanup tries to release memory!
1597 : */
1598 : void
1599 : AllocSetCheck(MemoryContext context)
1600 : {
1601 : AllocSet set = (AllocSet) context;
1602 : const char *name = set->header.name;
1603 : AllocBlock prevblock;
1604 : AllocBlock block;
1605 : Size total_allocated = 0;
1606 :
1607 : for (prevblock = NULL, block = set->blocks;
1608 : block != NULL;
1609 : prevblock = block, block = block->next)
1610 : {
1611 : char *bpoz = ((char *) block) + ALLOC_BLOCKHDRSZ;
1612 : long blk_used = block->freeptr - bpoz;
1613 : long blk_data = 0;
1614 : long nchunks = 0;
1615 : bool has_external_chunk = false;
1616 :
1617 : if (IsKeeperBlock(set, block))
1618 : total_allocated += block->endptr - ((char *) set);
1619 : else
1620 : total_allocated += block->endptr - ((char *) block);
1621 :
1622 : /*
1623 : * Empty block - empty can be keeper-block only
1624 : */
1625 : if (!blk_used)
1626 : {
1627 : if (!IsKeeperBlock(set, block))
1628 : elog(WARNING, "problem in alloc set %s: empty block %p",
1629 : name, block);
1630 : }
1631 :
1632 : /*
1633 : * Check block header fields
1634 : */
1635 : if (block->aset != set ||
1636 : block->prev != prevblock ||
1637 : block->freeptr < bpoz ||
1638 : block->freeptr > block->endptr)
1639 : elog(WARNING, "problem in alloc set %s: corrupt header in block %p",
1640 : name, block);
1641 :
1642 : /*
1643 : * Chunk walker
1644 : */
1645 : while (bpoz < block->freeptr)
1646 : {
1647 : MemoryChunk *chunk = (MemoryChunk *) bpoz;
1648 : Size chsize,
1649 : dsize;
1650 :
1651 : /* Allow access to the chunk header. */
1652 : VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
1653 :
1654 : if (MemoryChunkIsExternal(chunk))
1655 : {
1656 : chsize = block->endptr - (char *) MemoryChunkGetPointer(chunk); /* aligned chunk size */
1657 : has_external_chunk = true;
1658 :
1659 : /* make sure this chunk consumes the entire block */
1660 : if (chsize + ALLOC_CHUNKHDRSZ != blk_used)
1661 : elog(WARNING, "problem in alloc set %s: bad single-chunk %p in block %p",
1662 : name, chunk, block);
1663 : }
1664 : else
1665 : {
1666 : int fidx = MemoryChunkGetValue(chunk);
1667 :
1668 : if (!FreeListIdxIsValid(fidx))
1669 : elog(WARNING, "problem in alloc set %s: bad chunk size for chunk %p in block %p",
1670 : name, chunk, block);
1671 :
1672 : chsize = GetChunkSizeFromFreeListIdx(fidx); /* aligned chunk size */
1673 :
1674 : /*
1675 : * Check the stored block offset correctly references this
1676 : * block.
1677 : */
1678 : if (block != MemoryChunkGetBlock(chunk))
1679 : elog(WARNING, "problem in alloc set %s: bad block offset for chunk %p in block %p",
1680 : name, chunk, block);
1681 : }
1682 : dsize = chunk->requested_size; /* real data */
1683 :
1684 : /* an allocated chunk's requested size must be <= the chsize */
1685 : if (dsize != InvalidAllocSize && dsize > chsize)
1686 : elog(WARNING, "problem in alloc set %s: req size > alloc size for chunk %p in block %p",
1687 : name, chunk, block);
1688 :
1689 : /* chsize must not be smaller than the first freelist's size */
1690 : if (chsize < (1 << ALLOC_MINBITS))
1691 : elog(WARNING, "problem in alloc set %s: bad size %zu for chunk %p in block %p",
1692 : name, chsize, chunk, block);
1693 :
1694 : /*
1695 : * Check for overwrite of padding space in an allocated chunk.
1696 : */
1697 : if (dsize != InvalidAllocSize && dsize < chsize &&
1698 : !sentinel_ok(chunk, ALLOC_CHUNKHDRSZ + dsize))
1699 : elog(WARNING, "problem in alloc set %s: detected write past chunk end in block %p, chunk %p",
1700 : name, block, chunk);
1701 :
1702 : /* if chunk is allocated, disallow access to the chunk header */
1703 : if (dsize != InvalidAllocSize)
1704 : VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
1705 :
1706 : blk_data += chsize;
1707 : nchunks++;
1708 :
1709 : bpoz += ALLOC_CHUNKHDRSZ + chsize;
1710 : }
1711 :
1712 : if ((blk_data + (nchunks * ALLOC_CHUNKHDRSZ)) != blk_used)
1713 : elog(WARNING, "problem in alloc set %s: found inconsistent memory block %p",
1714 : name, block);
1715 :
1716 : if (has_external_chunk && nchunks > 1)
1717 : elog(WARNING, "problem in alloc set %s: external chunk on non-dedicated block %p",
1718 : name, block);
1719 : }
1720 :
1721 : Assert(total_allocated == context->mem_allocated);
1722 : }
1723 :
1724 : #endif /* MEMORY_CONTEXT_CHECKING */
|
