Lines Matching refs:Chunks
3239 " allocator, that maintains pools of quickly recycled chunks.\n" +
3267 " independent_calloc(size_t n_elements, size_t size, Void_t* chunks[]);\n" +
3268 " independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);\n" +
3564 " Because freed chunks may be overwritten with bookkeeping fields, this\n" +
3649 " MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.\n" +
3679 " of small chunks.\n" +
3683 " memory in programs that use many small chunks. You can get\n" +
3685 " lead to even greater slowdowns in programs using many small chunks.\n" +
3687 " only those chunks bordering topmost memory from being placed in\n" +
3803 " Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks\n" +
3924 " If you do not have mmap, operations involving very large chunks (1MB\n" +
4084 " int ordblks; /* number of free chunks */\n" +
4175 " Large chunks that were internally obtained via mmap will always\n" +
4252 " ordblks: the number of free chunks\n" +
4253 " smblks: the number of fastbin blocks (i.e., small chunks that\n" +
4277 " independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);\n" +
4288 " The \"chunks\" argument is optional (i.e., may be null, which is\n" +
4291 " no longer needed. Otherwise, the chunks array must be of at least\n" +
4293 " chunks.\n" +
4296 " null if the allocation failed. If n_elements is zero and \"chunks\"\n" +
4335 " independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);\n" +
4338 " chunks with sizes indicated in the \"sizes\" array. It returns\n" +
4345 " The \"chunks\" argument is optional (i.e., may be null). If it is null\n" +
4347 " be freed when it is no longer needed. Otherwise, the chunks array\n" +
4349 " pointers to the chunks.\n" +
4352 " null if the allocation failed. If n_elements is zero and chunks is\n" +
4376 " void* chunks[3];\n" +
4377 " if (independent_comalloc(3, sizes, chunks) == 0)\n" +
4379 " struct Head* head = (struct Head*)(chunks[0]);\n" +
4380 " char* body = (char*)(chunks[1]);\n" +
4381 " struct Foot* foot = (struct Foot*)(chunks[2]);\n" +
4390 " since it cannot reuse existing noncontiguous small chunks that\n" +
4434 " locked between two used chunks, so they cannot be given back to\n" +
4486 " zero even when no user-level chunks are allocated.\n" +
4506 " that hold returned chunks without consolidating their spaces. This\n" +
4507 " enables future requests for chunks of the same size to be handled\n" +
4547 " afterward allocate more large chunks) the value should be high\n" +
4567 " program undergoes phases where several large chunks are\n" +
4570 " chunks at all. And in well-behaved long-lived programs,\n" +
4588 " instead delayed until subsequent freeing of larger chunks. However,\n" +
4645 " Using mmap segregates relatively large chunks of memory so that\n" +
4657 " other chunks, as can happen with normally allocated chunks, which\n" +
4665 " used to service later requests, as happens with normal chunks.\n" +
4675 " \"large\" chunks, but the value of \"large\" varies across systems. The\n" +
4921 "Void_t** public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks) {\n" +
4926 " m = iCALLOc(n, elem_size, chunks);\n" +
4932 "Void_t** public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks) {\n" +
4937 " m = iCOMALLOc(n, sizes, chunks);\n" +
5137 " Chunks of memory are maintained using a `boundary tag' method as\n" +
5140 " survey of such techniques.) Sizes of free chunks are stored both\n" +
5142 " consolidating fragmented chunks into bigger chunks very fast. The\n" +
5143 " size fields also hold bits representing whether chunks are free or\n" +
5167 " Chunks always begin on even word boundries, so the mem portion\n" +
5171 " Free chunks are stored in circular doubly-linked lists, and look like this:\n" +
5213 " 2. Chunks allocated via mmap, which have the second-lowest-order\n" +
5289 " macros for which mmapped chunks should never be seen. This should\n" +
5359 " An array of bin headers for free chunks. Each bin is doubly\n" +
5364 " and consolidated sets of chunks, which is what these bins hold, so\n" +
5368 " inuse chunks or the ends of memory.\n" +
5370 " Chunks in bins are kept in size order, with ties going to the\n" +
5372 " for the small bins, which all contain the same-sized chunks, but\n" +
5373 " facilitates best-fit allocation for larger chunks. These lists\n" +
5378 " Chunks of the same size are linked with the most\n" +
5382 " adjacent freed chunks, resulting in larger free chunks and less\n" +
5415 " Bins for sizes < 512 bytes contain chunks of all the same size, spaced\n" +
5507 " Unsorted chunks\n" +
5509 " All remainders from chunk splits, as well as all returned chunks,\n" +
5513 " with chunks being placed on it in free (and malloc_consolidate),\n" +
5517 "/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */\n" +
5567 " An array of lists holding recently freed small chunks. Fastbins\n" +
5569 " since chunks are never removed from the middles of these lists,\n" +
5575 " Chunks in fastbins keep their inuse bit set, so they cannot\n" +
5576 " be consolidated with other free chunks. malloc_consolidate\n" +
5577 " releases all chunks in fastbins and consolidates them with\n" +
5578 " other free chunks.\n" +
5594 " fastbin chunks. This is a heuristic, so the exact value should not\n" +
5598 " consolidation reduces fragmentation surrounding loarge chunks even\n" +
5612 " freed chunks at all. It is set true when entering a chunk into any\n" +
5624 " some fastbin chunks. It is set true on entering a chunk into any\n" +
5825 " Properties of all chunks\n" +
5875 " Properties of free chunks\n" +
5915 " Properties of inuse chunks\n" +
5929 " return; /* mmapped chunks have no next/prev */\n" +
5937 " /* ... and is surrounded by OK chunks.\n" +
5938 " Since more things can be checked with free chunks than inuse ones,\n" +
5957 " Properties of chunks recycled from fastbins\n" +
5981 " Properties of nonrecycled chunks at the point they are malloced\n" +
5999 " chunk. This does not necessarily hold however for chunks\n" +
6105 " /* chunk is followed by a legal chain of inuse chunks */\n" +
6202 " Round up size to nearest page. For mmapped chunks, the overhead\n" +
6203 " is one SIZE_SZ unit larger than for normal chunks, because there\n" +
6372 " * We need to ensure that all returned chunks from malloc will meet\n" +
6496 " we don't own. These fenceposts are artificial chunks that are\n" +
6712 " (For a large request, we need to wait until unsorted chunks are\n" +
6750 " Process recently freed or remaindered chunks, taking one only if\n" +
6752 " the most recent non-exact fit. Place other traversed chunks in\n" +
6754 " chunks are placed in bins.\n" +
6839 " If a large request, scan through the chunks of current bin to\n" +
6842 " the only step where an unbounded number of chunks might be\n" +
7038 " If TRIM_FASTBINS set, don't place chunks\n" +
7052 " Consolidate other non-mmapped chunks as they arrive.\n" +
7081 " Place the chunk in unsorted chunk list. Chunks are\n" +
7113 " chunks. Then, if the total unused topmost memory exceeds trim\n" +
7163 " down chunks held in fastbins. Free itself cannot be used for this\n" +
7164 " purpose since, among other things, it might place chunks back onto\n" +
7209 " until malloc is sure that chunks aren't immediately going to be\n" +
7571 " /* For mmapped chunks, just adjust offset */\n" +
7693 "Void_t** iCALLOc(size_t n_elements, size_t elem_size, Void_t* chunks[])\n" +
7695 "Void_t** iCALLOc(n_elements, elem_size, chunks) size_t n_elements; size_t elem_size; Void_t* chunks[];\n" +
7700 " return iALLOc(n_elements, &sz, 3, chunks);\n" +
7708 "Void_t** iCOMALLOc(size_t n_elements, size_t sizes[], Void_t* chunks[])\n" +
7710 "Void_t** iCOMALLOc(n_elements, sizes, chunks) size_t n_elements; size_t sizes[]; Void_t* chunks[];\n" +
7713 " return iALLOc(n_elements, sizes, 0, chunks);\n" +
7732 " Void_t* chunks[])\n" +
7734 "static Void_t** iALLOc(n_elements, sizes, opts, chunks) size_t n_elements; size_t* sizes; int opts; Void_t* chunks[];\n" +
7744 " Void_t** marray; /* either \"chunks\" or malloced ptr array */\n" +
7754 " if (chunks != 0) {\n" +
7756 " return chunks; /* nothing to do */\n" +
7757 " marray = chunks;\n" +
7832 " if (marray != chunks) {\n" +
8124 " addresses, it must be OK for malloc'ed chunks to span multiple\n" +
