malloc源码分析---5

最新推荐文章于 2024-07-27 17:28:42 发布
最新推荐文章于 2024-07-27 17:28:42 发布
阅读量3.3k 收藏 6
点赞数 1
分类专栏： glibc+linux源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/conansonic/article/details/50279021
版权

malloc源码分析—sysmalloc

本章主要分析sysmalloc的代码，在《malloc源码分析—2》中已经分析了部分sysmalloc的代码，主要用于对分配区进行初始化。本章查看余下的代码，

第一部分

static void * sysmalloc(INTERNAL_SIZE_T nb, mstate av) {
    mchunkptr old_top;
    INTERNAL_SIZE_T old_size;
    char *old_end;

    long size;
    char *brk;

    long correction;
    char *snd_brk;

    INTERNAL_SIZE_T front_misalign;
    INTERNAL_SIZE_T end_misalign;
    char *aligned_brk;

    mchunkptr p;
    mchunkptr remainder;
    unsigned long remainder_size;

    size_t pagesize = GLRO(dl_pagesize);
    bool tried_mmap = false;

    ...

    old_top = av->top;
    old_size = chunksize(old_top);
    old_end = (char *) (chunk_at_offset(old_top, old_size));
    brk = snd_brk = (char *) (MORECORE_FAILURE);

    if (av != &main_arena) {
        heap_info *old_heap, *heap;
        size_t old_heap_size;

        old_heap = heap_for_ptr(old_top);
        old_heap_size = old_heap->size;
        if ((long) (MINSIZE + nb - old_size) > 0
                && grow_heap(old_heap, MINSIZE + nb - old_size) == 0) {
            av->system_mem += old_heap->size - old_heap_size;
            arena_mem += old_heap->size - old_heap_size;
            set_head(old_top,
                    (((char *) old_heap + old_heap->size) - (char *) old_top) | PREV_INUSE);
        } else if ((heap = new_heap(nb + (MINSIZE + sizeof(*heap)), mp_.top_pad))) {
            heap->ar_ptr = av;
            heap->prev = old_heap;
            av->system_mem += heap->size;
            arena_mem += heap->size;
            top (av) = chunk_at_offset(heap, sizeof(*heap));
            set_head(top (av), (heap->size - sizeof (*heap)) | PREV_INUSE);

            old_size = (old_size - MINSIZE ) & ~MALLOC_ALIGN_MASK;
            set_head(chunk_at_offset (old_top, old_size + 2 * SIZE_SZ),
                    0 | PREV_INUSE);
            if (old_size >= MINSIZE) {
                set_head(chunk_at_offset (old_top, old_size),
                        (2 * SIZE_SZ) | PREV_INUSE);
                set_foot(chunk_at_offset (old_top, old_size), (2 * SIZE_SZ));
                set_head(old_top, old_size | PREV_INUSE | NON_MAIN_ARENA);
                _int_free(av, old_top, 1);
            } else {
                set_head(old_top, (old_size + 2 * SIZE_SZ) | PREV_INUSE);
                set_foot(old_top, (old_size + 2 * SIZE_SZ));
            }
        } else if (!tried_mmap)
            goto try_mmap;
    }
    else{

        ...

    }

    ...

}

首先，old_top、old_size和old_end分别保存了top chunk的指针，大小以及尾部的地址。
如果是非主分配区，首先通过heap_for_ptr获得原top chunk对应的heap_info指针，

#define heap_for_ptr(ptr) \
  ((heap_info *) ((unsigned long) (ptr) & ~(HEAP_MAX_SIZE - 1)))

对于非主分配区，因为每个heap是按照HEAP_MAX_SIZE的大小分配且对齐的，而每个topchunk存在于每个heap的剩余空间（高地址处），因此通过heap_for_ptr就能取出heap_info指针，heap_info保存了每个heap的相关信息。获得heap_info指针后，就能获得该heap当前被使用的大小并将其保存在old_heap_size中。
根据《malloc源码分析—4》，进入到sysmalloc前会尝试在top chunk分配内存，因此代码执行到这里肯定失败了。所以这里只有MINSIZE + nb - old_size>0这一种情况，即这时的top chunk空间不足了，因此首先通过grow_heap尝试向heap的高地址处增加heap当前使用的大小，即top chunk的大小，

static int grow_heap(heap_info *h, long diff) {
    size_t pagesize = GLRO(dl_pagesize);
    long new_size;

    diff = ALIGN_UP(diff, pagesize);
    new_size = (long) h->size + diff;
    if ((unsigned long) new_size > (unsigned long) HEAP_MAX_SIZE)
        return -1;

    if ((unsigned long) new_size > h->mprotect_size) {
        if (__mprotect((char *) h + h->mprotect_size,
                (unsigned long) new_size - h->mprotect_size,
                PROT_READ | PROT_WRITE) != 0)
            return -2;

        h->mprotect_size = new_size;
    }

    h->size = new_size;
    LIBC_PROBE(memory_heap_more, 2, h, h->size);
    return 0;
}

这段代码其实最关键的是h->size = new_size这一样，表示重新设置heap的大小至new_size。
回到sysmalloc中，假设grow_heap成功，即将top chunk的大小设置为MINSIZE + nb，则重新设置分配区使用的内存大小，并且设置top chunk的size至新值（注意这里的size不能直接设置为MINSIZE + nb是因为在grow_heap中有对齐操作）。

假设grow_heap失败，大部分情况下说明heap的使用大小已经接近其最大值HEAP_MAX_SIZE了，此时只能通过new_heap重新分配一个heap，注意传入的参数mp_.top_pad表示在分配内存时，额外多分配的内存。

static heap_info * internal_function new_heap(size_t size, size_t top_pad) {
    size_t pagesize = GLRO(dl_pagesize);
    char *p1, *p2;
    unsigned long ul;
    heap_info *h;

    if (size + top_pad < HEAP_MIN_SIZE)
        size = HEAP_MIN_SIZE;
    else if (size + top_pad <= HEAP_MAX_SIZE)
        size += top_pad;
    else if (size > HEAP_MAX_SIZE)
        return 0;
    else
        size = HEAP_MAX_SIZE;
    size = ALIGN_UP(size, pagesize);

    p2 = MAP_FAILED;
    if (aligned_heap_area) {
        p2 = (char *) MMAP(aligned_heap_area, HEAP_MAX_SIZE, PROT_NONE,
                MAP_NORESERVE);
        aligned_heap_area = NULL;
        if (p2 != MAP_FAILED && ((unsigned long) p2 & (HEAP_MAX_SIZE - 1))) {
            __munmap(p2, HEAP_MAX_SIZE);
            p2 = MAP_FAILED;
        }
    }
    if (p2 == MAP_FAILED) {
        p1 = (char *) MMAP(0, HEAP_MAX_SIZE << 1, PROT_NONE, MAP_NORESERVE);
        if (p1 != MAP_FAILED) {
            p2 = (char *) (((unsigned long) p1 + (HEAP_MAX_SIZE - 1))
                    & ~(HEAP_MAX_SIZE - 1));
            ul = p2 - p1;
            if (ul)
                __munmap(p1, ul);
            else
                aligned_heap_area = p2 + HEAP_MAX_SIZE;
            __munmap(p2 + HEAP_MAX_SIZE, HEAP_MAX_SIZE - ul);
        } else {
            p2 = (char *) MMAP(0, HEAP_MAX_SIZE, PROT_NONE, MAP_NORESERVE);
            if (p2 == MAP_FAILED)
                return 0;

            if ((unsigned long) p2 & (HEAP_MAX_SIZE - 1)) {
                __munmap(p2, HEAP_MAX_SIZE);
                return 0;
            }
        }
    }
    if (__mprotect(p2, size, PROT_READ | PROT_WRITE) != 0) {
        __munmap(p2, HEAP_MAX_SIZE);
        return 0;
    }
    h = (heap_info *) p2;
    h->size = size;
    h->mprotect_size = size;
    LIBC_PROBE(memory_heap_new, 2, h, h->size);
    return h;
}

首先对需要分配的内存大小size做相应的调整。aligned_heap_area表示上一次MMAP分配后的结束地址，如果存在，就首先尝试从该地址分配大小为HEAP_MAX_SIZE的内存。MMAP最后是系统调用，对应的内核函数在《malloc源码分析—2》中已经介绍过了，这里只是一些标志位的区别。分配完后，会检查地址是否对齐，如果不对齐也是失败。
如果第一次分配失败了，就会再尝试一次，这次分配HEAP_MAX_SIZE*2大小的内存，并且新内存的起始地址由内核决定。因为尝试分配了HEAP_MAX_SIZE*2大小的内存，其中必定包含了大小为HEAP_MAX_SIZE且和HEAP_MAX_SIZE对齐的内存，因此一旦分配成功，就从中截取出这部分内存。
如果连第二次也分配失败了，就会通过MMAP进行第三次分配，这次只分配HEAP_MAX_SIZE大小的内存，并且起始地址由内核决定，如果又失败了就返回0。
如果三面三次分配内存任何一次成功，就设置相应的可读写位置，并且返回分配区的heap_info指针。

重新回到sysmalloc中，假设分配成功，就会对刚刚分配得到的heap做相应的设置，其中ar_ptr表示所属的分配区的指针，prev表示上一个heap，所有的heap通过prev形成单向链表，然后通过set_head设置av分配区top chunk的size，这里也可以看出，对于刚分配的heap，包含了heap_info指针、top chunk、以及大于size的未被使用的部分。
再接下来就要对原来的top chunk进行最后的处理，这里假设对齐，如果原top chunk的大小不够大，就将其分割成old_size + 2 * SIZE_SZ和2 * SIZE_SZ大小；如果原top chunk的大小足够大，就将其分割成old_size，2 * SIZE_SZ和2 * SIZE_SZ大小，并通过_int_free进行释放。

第二部分

继续往下看sysmalloc，上面一部分代码主要是针对非主分配区的操作，下面的这段代码就是针对主分配区的操作了。

static void * sysmalloc(INTERNAL_SIZE_T nb, mstate av) {

    ...

    if (av != &main_arena) {

        ...

    }
    else{
        size = nb + mp_.top_pad + MINSIZE;
        if (contiguous(av))
            size -= old_size;
        size = ALIGN_UP(size, pagesize);

        if (size > 0) {
            brk = (char *) (MORECORE(size));
            LIBC_PROBE (memory_sbrk_more, 2, brk, size);
        }

        if (brk != (char *) (MORECORE_FAILURE)) {
            void (*hook)(void) = atomic_forced_read (__after_morecore_hook);
            if (__builtin_expect (hook != NULL, 0))
            (*hook)();
        }
        else{
            if (contiguous (av))
                size = ALIGN_UP (size + old_size, pagesize);

            if ((unsigned long) (size) < (unsigned long) (MMAP_AS_MORECORE_SIZE))
                size = MMAP_AS_MORECORE_SIZE;

            if ((unsigned long) (size) > (unsigned long) (nb)){
                char *mbrk = (char *) (MMAP (0, size, PROT_READ | PROT_WRITE, 0));

                if (mbrk != MAP_FAILED){
                    brk = mbrk;
                    snd_brk = brk + size;
                    set_noncontiguous (av);
                }
            }
        }

        ...

    }

    ...

}

MORECORE是一个宏定义，其最终是通过系统调用分配内存，定义在linux内核的mmap.c文件中，

SYSCALL_DEFINE1(brk, unsigned long, brk){

    unsigned long retval;
    unsigned long newbrk, oldbrk;
    struct mm_struct *mm = current->mm;
    unsigned long min_brk;
    bool populate;

    down_write(&mm->mmap_sem);
    min_brk = mm->start_brk;
    if (brk < min_brk)
        goto out;

    if (check_data_rlimit(rlimit(RLIMIT_DATA), brk, mm->start_brk,
                  mm->end_data, mm->start_data))
        goto out;

    newbrk = PAGE_ALIGN(brk);
    oldbrk = PAGE_ALIGN(mm->brk);
    if (oldbrk == newbrk)
        goto set_brk;

    if (brk <= mm->brk) {
        if (!do_munmap(mm, newbrk, oldbrk-newbrk))
            goto set_brk;
        goto out;
    }

    if (find_vma_intersection(mm, oldbrk, newbrk+PAGE_SIZE))
        goto out;

    if (do_brk(oldbrk, newbrk-oldbrk) != oldbrk)
        goto out;

set_brk:
    mm->brk = brk;
    populate = newbrk > oldbrk && (mm->def_flags & VM_LOCKED) != 0;
    up_write(&mm->mmap_sem);
    if (populate)
        mm_populate(oldbrk, newbrk - oldbrk);
    return brk;

out:
    retval = mm->brk;
    up_write(&mm->mmap_sem);
    return retval;
}

首先会对传入堆的新地址brk做一些检查，然后该新地址小于原本的brk，就需要通过do_munmap释放虚拟内存，以减少堆的大小；反之，就通过do_brk增加堆得大小。其中find_vma_intersection用来判断增加堆空间后，是否会占用已经被分配的虚拟内存，

static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr){
    struct vm_area_struct * vma = find_vma(mm,start_addr);

    if (vma && end_addr <= vma->vm_start)
        vma = NULL;
    return vma;
}

因为是增加堆的大小，因此只需要关心do_brk函数，

static unsigned long do_brk(unsigned long addr, unsigned long len){

    struct mm_struct *mm = current->mm;
    struct vm_area_struct *vma, *prev;
    unsigned long flags;
    struct rb_node **rb_link, *rb_parent;
    pgoff_t pgoff = addr >> PAGE_SHIFT;
    int error;

    len = PAGE_ALIGN(len);
    if (!len)
        return addr;

    flags = VM_DATA_DEFAULT_FLAGS | VM_ACCOUNT | mm->def_flags;

    error = get_unmapped_area(NULL, addr, len, 0, MAP_FIXED);
    if (error & ~PAGE_MASK)
        return error;

    error = mlock_future_check(mm, mm->def_flags, len);
    if (error)
        return error;

    verify_mm_writelocked(mm);

    while (find_vma_links(mm, addr, addr + len, &prev, &rb_link,
                  &rb_parent)) {
        if (do_munmap(mm, addr, len))
            return -ENOMEM;
    }

    if (!may_expand_vm(mm, len >> PAGE_SHIFT))
        return -ENOMEM;

    if (mm->map_count > sysctl_max_map_count)
        return -ENOMEM;

    if (security_vm_enough_memory_mm(mm, len >> PAGE_SHIFT))
        return -ENOMEM;

    vma = vma_merge(mm, prev, addr, addr + len, flags,
                    NULL, NULL, pgoff, NULL);
    if (vma)
        goto out;

    vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
    if (!vma) {
        vm_unacct_memory(len >> PAGE_SHIFT);
        return -ENOMEM;
    }

    INIT_LIST_HEAD(&vma->anon_vma_chain);
    vma->vm_mm = mm;
    vma->vm_start = addr;
    vma->vm_end = addr + len;
    vma->vm_pgoff = pgoff;
    vma->vm_flags = flags;
    vma->vm_page_prot = vm_get_page_prot(flags);
    vma_link(mm, vma, prev, rb_link, rb_parent);
out:
    perf_event_mmap(vma);
    mm->total_vm += len >> PAGE_SHIFT;
    if (flags & VM_LOCKED)
        mm->locked_vm += (len >> PAGE_SHIFT);
    vma->vm_flags |= VM_SOFTDIRTY;
    return addr;
}

这段代码和第二章中分析的mmap_region函数很类似，这里简单分析如下，get_unmapped_area用来检查需要分配的虚拟内存地址是否已经被使用，find_vma_links用来查找需要插入的虚拟内存在红黑树的位置，may_expand_vm用来检查虚拟内存是否会超过系统的限制，vma_merge用来合并虚拟内存，如果不能合并，就通过slab分配一个vma，进行相应的设置，并通过vma_link插入到进程的红黑树中。

从linux的代码中回来，继续看sysmalloc，假设分配成功，会查找是否有__after_morecore_hook函数并执行，这里假设该函数指针为null。
假设分配失败，则进入else部分，首先对需要分配的大小按地址对齐，并且设置分配size的最小值为MMAP_AS_MORECORE_SIZE（1MB），然后通过MMAP宏分配内存，该函数已经在《malloc源码分析—2》分析过了。这里注意，如果是通过mmap分配的内存，则设置分配区为不连续标志位。

第三部分

继续往下看sysmalloc，

static void * sysmalloc(INTERNAL_SIZE_T nb, mstate av) {

    ...

    if (av != &main_arena) {

        ...

    }
    else{

        ...

        if (brk != (char *) (MORECORE_FAILURE)) {
            if (mp_.sbrk_base == 0)
                mp_.sbrk_base = brk;
            av->system_mem += size;

            if (brk == old_end && snd_brk == (char *) (MORECORE_FAILURE))
                set_head(old_top, (size + old_size) | PREV_INUSE);
            else if (contiguous (av) && old_size && brk < old_end) {
                malloc_printerr(3, "break adjusted to free malloc space", brk, av);
            }
            else {
                front_misalign = 0;
                end_misalign = 0;
                correction = 0;
                aligned_brk = brk;

                if (contiguous(av)) {
                    if (old_size)
                        av->system_mem += brk - old_end;

                    front_misalign = (INTERNAL_SIZE_T) chunk2mem(
                            brk) & MALLOC_ALIGN_MASK;
                    if (front_misalign > 0) {
                        correction = MALLOC_ALIGNMENT - front_misalign;
                        aligned_brk += correction;
                    }

                    correction += old_size;
                    end_misalign = (INTERNAL_SIZE_T) (brk + size + correction);
                    correction += (ALIGN_UP(end_misalign, pagesize)) - end_misalign;

                    assert(correction >= 0);
                    snd_brk = (char *) (MORECORE(correction));

                    if (snd_brk == (char *) (MORECORE_FAILURE)) {
                        correction = 0;
                        snd_brk = (char *) (MORECORE(0));
                    } else {
                        void (*hook)(
                        void) = atomic_forced_read (__after_morecore_hook);
                        if (__builtin_expect (hook != NULL, 0))
                        (*hook)();
                    }
                }

                ...
            }
        }
    }

    ...

}

假设增加了主分配区的top chunk成功，则更新sbrk_base和分配区已分配的内存大小。
然后，第一个判断表示，新分配的内存地址和原来的top chunk连续，并且不是通过MMAP分配的，这时只需要更新原来top chunk的大小size。
第二个判断表示如果分配区的连续标志位置位，top chunk的大小大于0，但是分配的brk小于原来的top chunk结束地址，这里就判定出错了。
进入第三个判断表示新分配的内存地址大于原来的top chunk的结束地址，但是不连续。这种情况下，如果分配区的连续标志位置位，则表示不是通过MMAP分配的，肯定有其他线程调用了brk在堆上分配了内存，av->system_mem += brk - old_end表示将其他线程分配的内存一并计入到该分配区分配的内存大小。然后将刚刚分配的地址brk按MALLOC_ALIGNMENT对齐。
再往下就要处理地址不连续的问题了，因为地址不连续，就要放弃原来top chunk后面一部分的内存大小，并且将这一部分内存大小“补上”到刚刚分配的新内存后面。首先计算堆上补上内存后的结束地址并保存在correction中，然后调用MORECORE继续分配一次，将新分配内存的开始地址保存在snd_brk中。如果分配失败，则将correction设为0，并将snd_brk重置为原来分配的内存的结束地址，表示放弃该次补偿操作；如果分配成功，就调用__after_morecore_hook函数，这里假设该函数指针为null。

第四部分

继续往下看sysmalloc，

static void * sysmalloc(INTERNAL_SIZE_T nb, mstate av) {

    ...

    if (av != &main_arena) {

        ...

    }
    else{

        ...

        if (brk != (char *) (MORECORE_FAILURE)) {

            ...

            if (brk == old_end && snd_brk == (char *) (MORECORE_FAILURE))
                ...
            else if (contiguous (av) && old_size && brk < old_end) {
                ...
            }
            else {

                ...

                if (contiguous(av)) {

                    ...

                }

                else{
                    if (MALLOC_ALIGNMENT == 2 * SIZE_SZ)
                    assert (((unsigned long) chunk2mem (brk) & MALLOC_ALIGN_MASK) == 0);
                    else{
                        front_misalign = (INTERNAL_SIZE_T) chunk2mem (brk) & MALLOC_ALIGN_MASK;
                        if (front_misalign > 0){
                            aligned_brk += MALLOC_ALIGNMENT - front_misalign;
                        }
                    }

                    if (snd_brk == (char *) (MORECORE_FAILURE)){
                        snd_brk = (char *) (MORECORE (0));
                    }
                }

                if (snd_brk != (char *) (MORECORE_FAILURE)) {
                    av->top = (mchunkptr) aligned_brk;
                    set_head(av->top,
                            (snd_brk - aligned_brk + correction) | PREV_INUSE);
                    av->system_mem += correction;

                    if (old_size != 0) {
                        old_size = (old_size - 4 * SIZE_SZ) & ~MALLOC_ALIGN_MASK;
                        set_head(old_top, old_size | PREV_INUSE);

                        chunk_at_offset (old_top, old_size)->size = (2 * SIZE_SZ)
                                | PREV_INUSE;

                        chunk_at_offset (old_top, old_size + 2 * SIZE_SZ)->size = (2
                                * SIZE_SZ) | PREV_INUSE;

                        if (old_size >= MINSIZE) {
                            _int_free(av, old_top, 1);
                        }
                    }
                }
            }
        }
    }

    ...

}

开头的else表示分配区的连续标志没有置位，这时只要按照MALLOC_ALIGNMENT做简单的对齐就行了，如果是通过brk分配的内存，则通过MORECORE (0)得到新分配的内存的结束地址并保存在snd_brk中。
再往下进入if，设置分配区的top指针为经过对齐之后的起始地址aligned_brk，设置top chunk的大小size，aligned_brk表示对齐造成的误差，correction是因为要补偿原来top chunk剩余内存造成的误差，然后设置分配区已分配的内存大小。
因为不连续，最后if内是设置原top chunk的fencepost，将原来top chunk的剩余空间拆成两个SIZE_SZ*2大小的chunk，如果剩下的大小大于可分配的chunk的最小值MINSIZE，就通过_int_free释放掉整个剩余内存。

第五部分

继续往下看sysmalloc最后一部分，

static void * sysmalloc(INTERNAL_SIZE_T nb, mstate av) {

    ...

    if ((unsigned long) av->system_mem > (unsigned long) (av->max_system_mem))
        av->max_system_mem = av->system_mem;
    check_malloc_state (av);

    p = av->top;
    size = chunksize(p);

    if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE )) {
        remainder_size = size - nb;
        remainder = chunk_at_offset(p, nb);
        av->top = remainder;
        set_head(p, nb | PREV_INUSE | (av != &main_arena ? NON_MAIN_ARENA : 0));
        set_head(remainder, remainder_size | PREV_INUSE);
        check_malloced_chunk (av, p, nb);
        return chunk2mem(p);
    }

    __set_errno(ENOMEM);
    return 0;
}

这里就是获得前面所有代码更新后的top chunk，然后从该top chunk中分配用户需要的大小chunk并返回，如果失败则返回0。

总结

简单总结一下sysmalloc函数，这里不包含《malloc源码分析—2》中的代码，该代码用于初始化。首先进入sysmalloc函数就表示top chunk的空间不够了。
假设当前分配区不是主分配区，就通过grow_heap增加top chunk的空间，如果失败就通过new_heap重新分配一个heap，并将该分配区的top chunk指针指向新分配的heap的空闲内存。
如果当前分配区是主分配区，首先会通过brk在堆上分配内存以增加top chunk的空间，如果失败再通过MMAP分配。假设新分配内存的地址不连续，而分配区的连续标志位置位，就会继续分配内存以补偿。
最后，只要分配成功，就可以从被更新的top chunk分配所需的内存。

二侠
关注
专栏目录
【学习札记NO.00003】基于libc-2.23版本的malloc源码简易分析 - Part-I - 堆内存的基本组织形式 by arttnba3
arttnba3的博客
01-19 1146
【学习札记NO.00003】基于libc-2.23版本的malloc源码简易分析 - Part-I - 堆内存的基本组织形式 by arttnba30x00.堆内存的组织形式一、malloc_chunk[The \_\_alignof\_\_ operator](https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_71/rzarg/sc09785202.htm?view=kc#ToC_180)二、chunk相关宏1.chunk size相关宏宏：off
MaixPy/openmv源码分析--bitmap
qq_32497777的博客
04-22 1341
在openmv对图像提取roi，这里用到了提取像素位的函数。 在collections.h中定义了相关的结构体和功能函数声明。 //////////// // bitmap // //////////// typedef struct bitmap { size_t size; char *data; } __attribute__((aligned(8)))bitmap_t; void bitmap_alloc(bitmap_t *ptr, size_t size); .
malloc的实现源码
08-03
malloc的源码实现，很方便移植。特别是在BootLoader或者单片机开发过程中，想要实现malloc、free、realloc等函数时，只需要将压缩包里的malloc.c和malloc.h拷贝到你的工程的同一个目录下，编译链接进去即可。压缩包里的test.c提供了一个使用示例供参考。【该malloc的实现改编自uboot源码】
malloc 源码
12-23 780
两个函数取自UNIX 版本6 malloc.c文件，一个为malloc函数，一个为mfree函数   2515:/*map数组是一个空闲资源列表，其中每个存储区由其长度和相对地址定义*/         struct map    2516: {   2517:         char *m_size;   2518:         char *m_addr;   2519: };
Linux 内核源码分析---内存管理
最新发布
学习记录
07-27 526
学习记录
malloc的源码剖析源
SmartWan的专栏
05-14 8149
对malloc的源码剖析源于我自己实现的共享内存分配器，使用buddy算法和红黑树结构实现对共享内存的分配回收管理，对其性能进行测试的时候，发现性能只有malloc的1/3~1/2，原本以为自己的实现性能应该比malloc高的，结果出乎意外，这让我产生窥探dlmalloc源码的好奇心，为此，找到http:
malloc源码分析---1
热门推荐
conansonic的博客
12-01 1万+
malloc源码分析 本文分析malloc的源码，首先从glibc开始，首先看malloc.c文件中的一段定义， strong_alias (__libc_malloc, __malloc) strong_alias (__libc_malloc, malloc) strong_alias是GNU C中的定义，编译器判定这里malloc是__libc_malloc的别名，__libc_m
malloc函数源代码
05-06
malloc函数的源代码，仅供参考学习。
商业源码-编程源码-上机系统（三级C语言）.zip
06-17
【标题】"商业源码-编程源码-上机系统（三级C语言）.zip" 涉及的是一款基于C语言开发的上机考试系统，适用于计算机三级考试的实践操作部分。C语言是一种广泛应用的编程语言，尤其在系统级编程、嵌入式开发以及底层...
商业源码-编程源码-C语言开发入门与编程实践源码.zip
06-14
这个压缩包内的源码很可能是对上述各个知识点的具体实例，通过阅读和分析这些源码，学习者可以巩固理论知识，提高解决问题的能力。同时，这些商业源码也可能包含了一些高级特性和优化技巧，对于进阶学习者来说，是很...
MALLOC Implementation-开源
05-03
学生和研究人员可以通过阅读和分析源码，了解内存管理的底层细节，甚至进行自己的实验和创新。这不仅促进了技术的发展，也培养了新一代的软件工程师。 总的来说，开源MALLOC的实现不仅为我们提供了高效、灵活的内存...
malloc源码分析glibc库
06-22
glibc内存管理ptmalloc源代码分析4.pdf
malloc实现源码
07-24
动态内存管理含有碎片收集策略，快速申请，方便移植，可以用于嵌入式系统中
c语言 malloc源码
06-25
c语言库文件 内存管理源代码 malloc free malloc_consolidate realloc
malloc()函数源代码
lxmky的专栏
10-26 1万+
#include "types.h" #include "stddef.h" #include "string.h" /* Imported functions */ extern void prom_printf (char *fmt, ...); static char *malloc_ptr = 0; static char *malloc_top = 0; static char *l
malloc源码分析---2
conansonic的博客
12-05 7160
malloc源码分析—_int_malloc 根据上一章的分析，malloc会调用__libc_malloc分配内存，__libc_malloc会调用malloc_hook_ini 进行初始化，然后回调__libc_malloc函数，这时候会执行_int_malloc开始分配内存，定义在malloc.c中，因为非常长，这里分段来看， _int_malloc第一部分 static void *
glibc-2.23学习笔记（一）—— malloc部分源码分析
qq_41988448的博客
11-30 2046
glibc-2.23学习笔记（一）—— malloc部分源码分析 搭建Glibc源码调试环境 1.下载并解压glibc源码 sudo apt-get install glibc-source cd /usr/src/glibc sudo tar xvf glibc-2.23.tar.xz 2.配置gdb 打开gdb配置文件 sudo vim ~/.gdbinit 在首行加入以下内容
malloc源码分析(4)--free后malloc&&double free
azraelxuemo的博客
03-17 1285
文章目录测试代码__libc_malloc__libc_malloc调用_int_malloc_int_malloc回到__libc_malloc如何利用double free测试代码测试代码2 之前我们从源码的角度分析了如何初始化heap并且从top chunk分配出了第一个块fast bin,那么这次我们结合free fastchunk来分配相同size的fastbin 测试代码 #include<malloc.h> int main(){ void *p=malloc(0x
ptmalloc源码剖析
chablin_的博客
03-31 3900
ptmalloc内存管理器 ptmalloc是glibc默认的内存管理器。我们常用的malloc和free就是由ptmalloc内存管理器提供的基础内存分配函数。ptmalloc有点像我们自己写的内存池，当我们通过malloc或者free函数来申请和释放内存的时候，ptmalloc会将这些内存管理起来，并且通过一些策略来判断是否需要回收给操作系统。这样做的最大好处就是：让用户申请内存和释放内存的...
FreeBSD内核malloc源码深度解析
"对FreeBSD-7内核中的malloc源码进行了深入分析，主要探讨了malloc的内存分配方式和对齐策略。文章作者通过删除部分辅助代码以简化分析，但指出仅看malloc的代码可能无法完全理解某些数据结构，建议同时参考free的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值