Lines Matching refs:bytes
37 Supported pointer/size_t representation: 4 or 8 bytes
44 Alignment: 8 bytes (default)
47 if necessary (up to 128bytes), at the expense of using more space.
49 Minimum overhead per allocated chunk: 4 or 8 bytes (if 4byte sizes)
50 8 or 16 bytes (if 8byte sizes)
55 Minimum allocated size: 4-byte ptrs: 16 bytes (including overhead)
56 8-byte ptrs: 32 bytes (including overhead)
58 Even a request for zero bytes (i.e., malloc(0)) returns a
60 The maximum overhead wastage (i.e., number of extra bytes
64 32 bytes plus the remainder from a system page (the minimal
65 mmap unit); typically 4096 or 8192 bytes.
142 than 256bytes, it deviates from best-fit when there is not an
181 #define mymalloc(bytes) mspace_malloc(mymspace, bytes)
189 void* tlmalloc(size_t bytes) {
191 return mspace_malloc(tlms, bytes);
366 This should be set if a call to realloc with zero bytes should
663 Returns a pointer to a newly allocated chunk of at least n bytes, or
668 size is 16 bytes on most 32bit systems, and 32 bytes on 64bit
688 Returns a pointer to n_elements * element_size bytes, with all locations
696 as does chunk p up to the minimum of (n, p's size) bytes, or null
708 if n is for fewer bytes than already held by p, the newly unused
720 Returns a pointer to a newly allocated chunk of n bytes, aligned
761 Returns the number of bytes obtained from the system. The total
762 number of bytes allocated by malloc, realloc etc., is less than this
772 Returns the maximum number of bytes obtained from the system. This
774 has been reclaimed by the system. The peak number of bytes allocated
788 arena: current total non-mmapped bytes allocated from system
792 hblkhd: total bytes held in mmapped regions
798 keepcost: the maximum number of bytes that could ideally be released
958 Returns the number of bytes you can actually use in
961 You can use this many bytes without worrying about
976 number of bytes allocated via malloc (or realloc, etc) but not yet
977 freed. Note that this is the number of bytes allocated, not the
1018 bytes freed. After destruction, the results of access to all memory
1025 of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this
1038 void* mspace_malloc(mspace msp, size_t bytes);
1071 void* mspace_memalign(mspace msp, size_t alignment, size_t bytes);
1088 mspace_footprint() returns the number of bytes obtained from the
1094 mspace_max_footprint() returns the peak number of bytes obtained from the
1262 /* the number of bytes to offset an address to align it */
1495 +- size - sizeof(size_t) available payload bytes -+
1517 +- size - sizeof(struct chunk) unused bytes -+
1640 /* pad request bytes into a usable size */
1723 `head:' | Size of chunk, in bytes |P|
1729 | Unused space (may be 0 bytes long) .
1733 `foot:' | Size of chunk, in bytes |
1738 free chunks greater than 256 bytes, their size doesn't impose any
1744 `head:' | Size of chunk, in bytes |P|
1761 `foot:' | Size of chunk, in bytes |
1951 with sizes less than MIN_LARGE_SIZE bytes. Each bin contains
1952 chunks of all the same size, spaced 8 bytes apart. To simplify
2510 ints must be at least 4 bytes.
2884 fprintf(stderr, "max system bytes = %10lu\n", (unsigned long)(maxfp));
2885 fprintf(stderr, "system bytes = %10lu\n", (unsigned long)(fp));
2886 fprintf(stderr, "in use bytes = %10lu\n", (unsigned long)(used));
3772 static void* internal_realloc(mstate m, void* oldmem, size_t bytes) {
3773 if (bytes >= MAX_REQUEST) {
3788 size_t nb = request2size(bytes);
3829 void* newmem = internal_malloc(m, bytes);
3832 memcpy(newmem, oldmem, (oc < bytes)? oc : bytes);
3843 static void* internal_memalign(mstate m, size_t alignment, size_t bytes) {
3845 return internal_malloc(m, bytes);
3854 if (bytes >= MAX_REQUEST - alignment) {
3860 size_t nb = request2size(bytes);
3949 size_t remainder_size; /* remaining bytes while splitting */
4061 void* dlmalloc(size_t bytes) {
4064 If a small request (< 256 bytes minus per-chunk overhead):
4066 (Remainderless means that there are too few excess bytes to
4088 if (bytes <= MAX_SMALL_REQUEST) {
4091 nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
4141 else if (bytes >= MAX_REQUEST)
4144 nb = pad_request(bytes);
4308 void* dlrealloc(void* oldmem, size_t bytes) {
4310 return dlmalloc(bytes);
4312 if (bytes == 0) {
4327 return internal_realloc(m, oldmem, bytes);
4331 void* dlmemalign(size_t alignment, size_t bytes) {
4332 return internal_memalign(gm, alignment, bytes);
4346 void* dlvalloc(size_t bytes) {
4350 return dlmemalign(pagesz, bytes);
4353 void* dlpvalloc(size_t bytes) {
4357 return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
4486 void* mspace_malloc(mspace msp, size_t bytes) {
4495 if (bytes <= MAX_SMALL_REQUEST) {
4498 nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
4548 else if (bytes >= MAX_REQUEST)
4551 nb = pad_request(bytes);
4711 void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) {
4713 return mspace_malloc(msp, bytes);
4715 if (bytes == 0) {
4731 return internal_realloc(ms, oldmem, bytes);
4735 void* mspace_memalign(mspace msp, size_t alignment, size_t bytes) {
4741 return internal_memalign(ms, alignment, bytes);
