前言

本篇文章介绍我们在日常开发使用Java时new对象的时，Dalvik在堆上的内存分配是如何分配的。内存又和gc相关，下篇文章会分析Dalvik的gc流程。

Dalvik内存管理

内存碎片问题其实是一个通用的问题，不单止Dalvik虚拟机在Java堆为对象分配内存时会遇到，C库的malloc函数在分配内存时也会遇到。Android系统使用的C库bionic使用了Doug Lea写的dlmalloc内存分配器。也就是说，我们调用函数malloc的时候，使用的是dlmalloc内存分配器来分配内存。
Dalvik虚拟机的Java堆的底层实现是一块匿名共享内存，并且将其抽象为C库的一个mspace，即Dalvik虚拟机是利用的C库里面的dlmalloc内存分配器来解决内存碎片问题。
从Dailvk代码设计上存在两种内存限制，这两种限制在随着内存分配堆增长的过程中在不断调整，本篇文章分析内存分配流程，有机会分析内存管理这块，即Dalvik是如何调整堆的算法的，也比较复杂：

一是Dalvik设计的softLimit，即在Active堆中可以分配的内存上限；
二是mspace的hardLimit限制，即是匿名共享内存里的mspace_footprint限制；

对象创建内存分配流程

Java中进行对象分配最终会通过tryMalloc进行内存分配
tryMalloc操作的核心方法是dvmHeapSourceAlloc和dvmHeapSourceAllocAndGrow
tryMalloc中，首次调用dvmHeapSourceAlloc进行分配，此时如果分配成功，超过concurrentStartBytes时则会触发concurrent gc，此为并发gc，较为轻量级
dvmHeapSourceAlloc分配失败的原因可以是softlimit或mspace的footprint达到阈值
在首次执行dvmHeapSourceAlloc失败后触发GC_FOR_MALLOC进行同步内存回收，是stop world类型gc，最为耗时
如果此时还失败的话，会尝试调用dvmHeapSourceAllocAndGrow，先remove掉softLimt尝试分配，不行的话再把footprint增到最大再分配，分配完成后会将footprint还原
如果调用dvmHeapSourceAllocAndGrow仍然失败，那么会触发GC_BEFORE_OOM进行回收，这里传入参数true表示也要讲软引用一块清除掉了
软引用清除掉后之后再会尝试dvmHeapSourceAllocAndGrow，如果还是失败，那么会抛出OutOfMemoryError错误

Heap.cpp

dvmMalloc

Java的动态内存分配是通过new操作符完成的，而最终调用的是dvmMalloc()函数，Dalvik在内存分配上也在尽力分配出内存，直到最后OOM。

// Allocate storage on the GC heap.  We guarantee 8-byte alignment.
void* dvmMalloc(size_t size, int flags)
{
    void *ptr;

    dvmLockHeap();
    // Try as hard as possible to allocate some memory.
    ptr = tryMalloc(size);
    dvmUnlockHeap();

    if (ptr != NULL) {
        // track it，此处在下篇文章分析，这里可以dump出来分配的内存和堆栈
        if ((flags & ALLOC_DONT_TRACK) == 0) {
            dvmAddTrackedAlloc((Object*)ptr, NULL);
        }
    } else {
        // The allocation failed; throw an OutOfMemoryError.
        throwOOME();
    }

    return ptr;
}

tryMalloc

// Try as hard as possible to allocate some memory.
static void *tryMalloc(size_t size)
{
    void *ptr;
    ptr = dvmHeapSourceAlloc(size);
    if (ptr != NULL) {
        return ptr;
    }

    // The allocation failed.  If the GC is running, block until it completes and retry.
    if (gDvm.gcHeap->gcRunning) {
        // The GC is concurrently tracing the heap.  Release the heap lock, wait for the GC to complete, and retrying allocating.
        dvmWaitForConcurrentGcToComplete();
    } else {
      // Try a foreground GC since a concurrent GC is not currently running.
      gcForMalloc(false); 
    }

    ptr = dvmHeapSourceAlloc(size);
    if (ptr != NULL) {
        return ptr;
    }

    // Even that didn't work;  this is an exceptional state. Try harder, growing the heap if necessary.
    ptr = dvmHeapSourceAllocAndGrow(size);
    if (ptr != NULL) {
    	// may want to grow a little bit more so that the amount of free space is equal to the old free space + the utilization slop for the new allocation.
        size_t newHeapSize;
        newHeapSize = dvmHeapSourceGetIdealFootprint();
        return ptr;
    }

    /* Most allocations should have succeeded by now, so the heap
     * is really full, really fragmented, or the requested size is
     * really big.  Do another GC, collecting SoftReferences this
     * time.  The VM spec requires that all SoftReferences have
     * been collected and cleared before throwing an OOME.
     */
    gcForMalloc(true);
    ptr = dvmHeapSourceAllocAndGrow(size);
    if (ptr != NULL) {
        return ptr;
    }
    dvmDumpThread(dvmThreadSelf(), false);
    return NULL;
}

HeapSouce.cpp

dvmHeapSourceAlloc

// Allocates <n> bytes of zeroed data.
void* dvmHeapSourceAlloc(size_t n) {
    HeapSource *hs = gHs;
    Heap* heap = hs2heap(hs);

    if (heap->bytesAllocated + n > hs->softLimit) {
        // softLimit限制；This allocation would push us over the soft limit; act as if the heap is full.
        return NULL;
    }
    void* ptr = mspace_calloc(heap->msp, 1, n);
    if (ptr == NULL) {
    	// hardLimit限制
    	return NULL;
    }

    countAllocation(heap, ptr);
    // Check to see if a concurrent GC should be initiated. The garbage collector thread is already running or has yet to be started.  Do nothing.
    if (gDvm.gcHeap->gcRunning || !hs->hasGcThread) {
        return ptr;
    }
    // 唤醒concurrent gc. We have exceeded the allocation threshold.  Wake up the garbage collector.
    if (heap->bytesAllocated > heap->concurrentStartBytes) {
        dvmSignalCond(&gHs->gcThreadCond);
    }
    return ptr;
}

dvmHeapSourceAllocAndGrow

// Allocates <n> bytes of zeroed data, growing as much as possible if necessary.
void* dvmHeapSourceAllocAndGrow(size_t n) {
    HeapSource *hs = gHs;
    Heap* heap = hs2heap(hs);
    void* ptr = dvmHeapSourceAlloc(n);
    if (ptr != NULL) {
        return ptr;
    }

    size_t oldIdealSize = hs->idealSize;
    // We're soft-limited.  Try removing the soft limit to see if we can allocate without actually growing.
    if (isSoftLimited(hs)) {
        hs->softLimit = SIZE_MAX;
        ptr = dvmHeapSourceAlloc(n);
        if (ptr != NULL) {
            snapIdealFootprint();
            return ptr;
        }
    }

    // We're not soft-limited.  Grow the heap to satisfy the request. If this call fails, no footprints will have changed.
    ptr = heapAllocAndGrow(hs, heap, n);
    if (ptr != NULL) {
        snapIdealFootprint();
    } else {
        setIdealFootprint(oldIdealSize);
    }
    return ptr;
}


// Remove any hard limits, try to allocate, and shrink back down. Last resort when trying to allocate an object.
static void* heapAllocAndGrow(HeapSource *hs, Heap *heap, size_t n)
{
    // Grow as much as possible, but don't let the real footprint go over the absolute max.
    size_t max = heap->maximumSize;
    mspace_set_footprint_limit(heap->msp, max);
    
    void* ptr = dvmHeapSourceAlloc(n);

    // Shrink back down as small as possible.  Our caller may readjust max_allowed to a more appropriate value.
    mspace_set_footprint_limit(heap->msp, mspace_footprint(heap->msp));
    
    return ptr;
}