Lines Matching refs:bytes
28 Return a pointer to a newly allocated chunk of at least n bytes, or null
34 as does chunk p up to the minimum of (n, p's size) bytes, or null
40 Return a pointer to a newly allocated chunk of n bytes, aligned
51 Returns a pointer to quantity * unit bytes, with all locations
56 Release all but pad bytes of freed top-most memory back
59 Report the number usable allocated bytes associated with allocated
60 chunk p. This may or may not report more bytes than were requested,
76 Assumed pointer representation: 4 or 8 bytes
81 Assumed size_t representation: 4 or 8 bytes
82 Note that size_t is allowed to be 4 bytes even if pointers are 8.
84 Minimum overhead per allocated chunk: 4 or 8 bytes
85 Each malloced chunk has a hidden overhead of 4 bytes holding size
88 Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
89 8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
92 ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
94 and 8 (16) bytes for free list pointers. Thus, the minimum
95 allocatable size is 16/24/32 bytes.
97 Even a request for zero bytes (i.e., malloc(0)) returns a
100 Maximum allocated size: 4-byte size_t: 2^31 - 8 bytes
101 8-byte size_t: 2^63 - 16 bytes
111 Maximum overhead wastage per allocated chunk: normally 15 bytes
114 make the normal worst-case wastage 15 bytes (i.e., up to 15
115 more bytes will be allocated than were requested in malloc), with
117 1. Because requests for zero bytes allocate non-zero space,
118 the worst case wastage for a request of zero bytes is 24 bytes.
120 mmap(), the worst case wastage is 8 bytes plus the remainder
121 from a system page (the minimal mmap unit); typically 4096 bytes.
309 realloc with zero bytes should be the same as a call to free.
1137 INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
1165 | Size of chunk, in bytes |P|
1169 . (malloc_usable_space() bytes) .
1189 `head:' | Size of chunk, in bytes |P|
1195 | Unused space (may be 0 bytes long) .
1199 `foot:' | Size of chunk, in bytes |
1220 become less than MINSIZE bytes long, it is replenished via
1284 /* pad request bytes into a usable size */
1405 Bins for sizes < 512 bytes contain chunks of all the same size, spaced
1406 8 bytes apart. Larger bins are approximately logarithmically
1503 bins for chunks < 512 are all spaced 8 bytes apart, and hold
1833 /* We demand that eight bytes into a page must be 8-byte aligned. */
1934 INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of sbrked space */
1935 INTERNAL_SIZE_T correction; /* bytes for 2nd sbrk call */
1964 if (brk == old_end) /* can just add bytes to current top */
1973 else /* Someone else called sbrk(). Count those bytes as sbrked_mem. */
2046 This currently means to add 4 bytes overhead plus possibly more to
2048 MINSIZE (currently 16 bytes), the smallest allocatable size.
2049 (All fits are considered `exact' if they are within MINSIZE bytes.)
2102 Void_t* mALLOc(size_t bytes)
2104 Void_t* mALLOc(bytes) size_t bytes;
2122 if ((long)bytes < 0) return 0;
2124 nb = request2size(bytes); /* padded request size; */
2481 a `small' (<512 bytes) size, then the newly unused space is lopped
2495 Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
2497 Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
2522 if (bytes == 0) { fREe(oldmem); return 0; }
2525 if ((long)bytes < 0) return 0;
2528 if (oldmem == 0) return mALLOc(bytes);
2534 nb = request2size(bytes);
2546 newmem = mALLOc(bytes);
2648 newmem = mALLOc (bytes);
2714 Void_t* mEMALIGn(size_t alignment, size_t bytes)
2716 Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
2729 if ((long)bytes < 0) return 0;
2733 if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
2741 nb = request2size(bytes);
2820 Void_t* vALLOc(size_t bytes)
2822 Void_t* vALLOc(bytes) size_t bytes;
2825 return mEMALIGn (malloc_getpagesize, bytes);
2835 Void_t* pvALLOc(size_t bytes)
2837 Void_t* pvALLOc(bytes) size_t bytes;
2841 return mEMALIGn (pagesize, (bytes + pagesize - 1) & ~(pagesize - 1));
2889 /* clear only the bytes from non-freshly-sbrked memory */
3003 This routine tells you how many bytes you can actually use in an
3005 often not). You can use this many bytes without worrying about
3086 of bytes allocated via malloc (or realloc, etc) but not yet
3087 freed. (Note that this is the number of bytes allocated, not the
3096 fprintf(stderr, "max system bytes = %10u\n",
3098 fprintf(stderr, "system bytes = %10u\n",
3100 fprintf(stderr, "in use bytes = %10u\n",