Lines Matching refs:av
2207 static void malloc_init_state(mstate av)
2209 static void malloc_init_state(av) mstate av;
2216 /* Uncomment this if you are not using a static av */
2217 /* MALLOC_ZERO(av, sizeof(struct malloc_state); */
2221 bin = bin_at(av,i);
2225 av->max_fast = req2max_fast(DEFAULT_MXFAST);
2227 av->top_pad = DEFAULT_TOP_PAD;
2228 av->n_mmaps_max = DEFAULT_MMAP_MAX;
2229 av->mmap_threshold = DEFAULT_MMAP_THRESHOLD;
2232 av->trim_threshold = DEFAULT_TRIM_THRESHOLD;
2233 av->sbrk_base = (char*)MORECORE_FAILURE;
2235 av->trim_threshold = (unsigned long)(-1);
2236 av->sbrk_base = NONCONTIGUOUS_REGIONS;
2239 av->top = initial_top(av);
2240 av->pagesize = malloc_getpagesize;
2298 mstate av = get_malloc_state();
2304 if (av->sbrk_base != NONCONTIGUOUS_REGIONS) {
2305 assert(((char*)p) >= ((char*)(av->sbrk_base)));
2308 if (p != av->top) {
2309 if (av->sbrk_base != NONCONTIGUOUS_REGIONS) {
2310 assert(((char*)p + sz) <= ((char*)(av->top)));
2314 if (av->sbrk_base != NONCONTIGUOUS_REGIONS) {
2315 assert(((char*)p + sz) <= ((char*)(av->sbrk_base) + av->sbrked_mem));
2328 if (av->sbrk_base != NONCONTIGUOUS_REGIONS) {
2329 assert(! (((char*)p) >= ((char*)av->sbrk_base) &&
2330 ((char*)p) < ((char*)(av->sbrk_base) + av->sbrked_mem)));
2333 assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
2355 mstate av = get_malloc_state();
2375 assert (next == av->top || inuse(next));
2396 mstate av = get_malloc_state();
2419 if (next == av->top) {
2490 mstate av = get_malloc_state();
2510 if (av->top == 0 || av->top == initial_top(av))
2514 assert((av->pagesize & (av->pagesize-1)) == 0);
2520 assert((av->max_fast & ~1) <= request2size(MAX_FAST_SIZE));
2522 max_fast_bin = fastbin_index(av->max_fast);
2525 p = av->fastbins[i];
2542 assert(have_fastchunks(av));
2546 b = bin_at(av,i);
2550 biton = get_binmap(av,i);
2572 q != av->top && inuse(q) && (long)(chunksize(q)) >= (long)MINSIZE;
2580 check_chunk(av->top);
2584 assert(total <= (unsigned long)(av->max_total_mem));
2585 assert(av->n_mmaps >= 0);
2586 assert(av->n_mmaps <= av->n_mmaps_max);
2587 assert(av->n_mmaps <= av->max_n_mmaps);
2588 assert(av->max_n_mmaps <= av->n_mmaps_max);
2590 assert((unsigned long)(av->sbrked_mem) <=
2591 (unsigned long)(av->max_sbrked_mem));
2593 assert((unsigned long)(av->mmapped_mem) <=
2594 (unsigned long)(av->max_mmapped_mem));
2596 assert((unsigned long)(av->max_total_mem) >=
2597 (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
2616 On entry, it is assumed that av->top does not have enough
2622 static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
2624 static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av;
2627 mchunkptr old_top; /* incoming value of av->top */
2648 size_t pagemask = av->pagesize - 1;
2658 if ((unsigned long)nb >= (unsigned long)(av->mmap_threshold) &&
2659 (av->n_mmaps < av->n_mmaps_max)) {
2696 if (++av->n_mmaps > av->max_n_mmaps)
2697 av->max_n_mmaps = av->n_mmaps;
2699 sum = av->mmapped_mem += size;
2700 if (sum > (unsigned long)(av->max_mmapped_mem))
2701 av->max_mmapped_mem = sum;
2702 sum += av->sbrked_mem;
2703 if (sum > (unsigned long)(av->max_total_mem))
2704 av->max_total_mem = sum;
2713 old_top = av->top;
2724 assert(old_top == initial_top(av) ||
2731 size = nb + av->top_pad + MINSIZE;
2739 if (av->sbrk_base != NONCONTIGUOUS_REGIONS)
2774 if (av->sbrk_base != NONCONTIGUOUS_REGIONS)
2794 av->sbrk_base = NONCONTIGUOUS_REGIONS;
2801 av->sbrked_mem += size;
2813 av->sbrk_base (MORECORE_FAILURE or NONCONTIGUOUS_REGIONS):
2839 if (av->sbrk_base != NONCONTIGUOUS_REGIONS) {
2850 prev_inuse of av->top (and any chunk created from its start)
2910 av->top = (mchunkptr)aligned_brk;
2911 set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
2913 av->sbrked_mem += correction;
2916 if (old_top == initial_top(av)) {
2917 if (av->sbrk_base == (char*)(MORECORE_FAILURE))
2918 av->sbrk_base = brk;
2960 sum = av->sbrked_mem;
2961 if (sum > (unsigned long)(av->max_sbrked_mem))
2962 av->max_sbrked_mem = sum;
2964 sum += av->mmapped_mem;
2965 if (sum > (unsigned long)(av->max_total_mem))
2966 av->max_total_mem = sum;
2972 p = av->top;
2979 av->top = remainder;
3004 static int sYSTRIm(size_t pad, mstate av)
3006 static int sYSTRIm(pad, av) size_t pad; mstate av;
3017 if (av->sbrk_base != NONCONTIGUOUS_REGIONS) {
3019 pagesz = av->pagesize;
3020 top_size = chunksize(av->top);
3032 if (current_brk == (char*)(av->top) + top_size) {
3052 av->sbrked_mem -= released;
3053 set_head(av->top, (top_size - released) | PREV_INUSE);
3078 mstate av = get_malloc_state();
3114 This code is safe to execute even if av not yet initialized, so we
3118 if (nb <= av->max_fast) {
3119 fb = &(av->fastbins[(fastbin_index(nb))]);
3138 bin = bin_at(av,idx);
3142 malloc_consolidate(av);
3167 if (have_fastchunks(av)) /* consolidation/initialization check */
3168 malloc_consolidate(av);
3188 while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
3200 victim == av->last_remainder &&
3201 bck == unsorted_chunks(av) &&
3206 unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
3207 av->last_remainder = remainder;
3208 remainder->bk = remainder->fd = unsorted_chunks(av);
3219 unsorted_chunks(av)->bk = bck;
3220 bck->fd = unsorted_chunks(av);
3234 bck = bin_at(av, victim_index);
3239 bck = bin_at(av, victim_index);
3260 mark_bin(av, victim_index);
3276 bin = bin_at(av, idx);
3297 unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
3298 remainder->bk = remainder->fd = unsorted_chunks(av);
3322 bin = bin_at(av,idx);
3324 map = av->binmap[block];
3337 else if ( (map = av->binmap[block]) != 0) {
3338 bin = bin_at(av, (block << BINMAPSHIFT));
3358 av->binmap[block] = map &= ~bit; /* Write through */
3387 unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
3388 remainder->bk = remainder->fd = unsorted_chunks(av);
3391 av->last_remainder = remainder;
3416 victim = av->top;
3422 av->top = remainder;
3436 else if (have_fastchunks(av)) {
3439 malloc_consolidate(av);
3446 return sYSMALLOc(nb, av);
3463 mstate av = get_malloc_state();
3489 if ((unsigned long)size <= (unsigned long)av->max_fast
3496 && (chunk_at_offset(p, size) != av->top)
3500 set_fastchunks(av);
3501 fb = &(av->fastbins[fastbin_index(size)]);
3524 if (nextchunk != av->top) {
3542 bck = unsorted_chunks(av);
3561 av->top = p;
3576 if ((unsigned long)(size) > (unsigned long)(av->trim_threshold / 2)) {
3577 if (have_fastchunks(av)) {
3578 malloc_consolidate(av);
3579 size = chunksize(av->top);
3582 if ((unsigned long)(size) > (unsigned long)(av->trim_threshold))
3583 sYSTRIm(av->top_pad, av);
3600 av->n_mmaps--;
3601 av->mmapped_mem -= (size + offset);
3626 static void malloc_consolidate(mstate av)
3628 static void malloc_consolidate(av) mstate av;
3652 if (av->max_fast == 0) {
3653 malloc_init_state(av);
3656 else if (have_fastchunks(av)) {
3657 clear_fastchunks(av);
3659 unsorted_bin = unsorted_chunks(av);
3669 maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
3670 fb = &(av->fastbins[0]);
3692 if (nextchunk != av->top) {
3715 av->top = p;
3769 mstate av = get_malloc_state();
3826 if (next == av->top) { /* Expand forward into top */
3831 av->top = chunk_at_offset(oldp, nb);
3832 set_head(av->top, (newsize - nb) | PREV_INUSE);
3843 av->top = chunk_at_offset(newp, nb);
3844 set_head(av->top, (newsize - nb) | PREV_INUSE);
3978 size_t pagemask = av->pagesize - 1;
4000 sum = av->mmapped_mem += newsize - oldsize;
4001 if (sum > (unsigned long)(av->max_mmapped_mem))
4002 av->max_mmapped_mem = sum;
4003 sum += av->sbrked_mem;
4004 if (sum > (unsigned long)(av->max_total_mem))
4005 av->max_total_mem = sum;
4246 mstate av = get_malloc_state();
4247 malloc_consolidate(av);
4248 return mEMALIGn(av->pagesize, bytes);
4263 mstate av = get_malloc_state();
4267 malloc_consolidate(av);
4269 pagesz = av->pagesize;
4302 mstate av = get_malloc_state();
4304 malloc_consolidate(av);
4306 return sYSTRIm(pad, av);
4344 mstate av = get_malloc_state();
4355 if (av->top == 0) malloc_consolidate(av);
4360 avail = chunksize(av->top);
4368 for (p = av->fastbins[i]; p != 0; p = p->fd) {
4378 b = bin_at(av, i);
4388 mi.uordblks = av->sbrked_mem - avail;
4389 mi.arena = av->sbrked_mem;
4390 mi.hblks = av->n_mmaps;
4391 mi.hblkhd = av->mmapped_mem;
4393 mi.keepcost = chunksize(av->top);
4394 mi.usmblks = av->max_total_mem;
4476 mstate av = get_malloc_state();
4478 malloc_consolidate(av);
4483 av->max_fast = req2max_fast(value);
4490 av->trim_threshold = value;
4494 av->top_pad = value;
4498 av->mmap_threshold = value;
4503 av->n_mmaps_max = value;
4509 av->n_mmaps_max = value;