LinearAllocator内存分配

简介：

在Android4.4中，在hwui将以前的绘制命令由原来的枚举类型，全部以类的形式呈现（一是为了便于扩展，二是由于加入延时渲染列表，不得不用类来实现），抽象类为DisplayListOp，在该类中重载了new的方法，即用了new placement的方式，统一分配内存，而不是每个操作自己分配，即用了LinearAllocator来管理每个操作需要申请的内存，这样能够提升申请内存的性能，同时能够便于统一管理。

class DisplayListOp {
public:
    // These objects should always be allocated with a LinearAllocator, and never destroyed/deleted.
    // standard new() intentionally not implemented, and delete/deconstructor should never be used.
    virtual ~DisplayListOp() { CRASH(); }
    static void operator delete(void* ptr) { CRASH(); }
    /** static void* operator new(size_t size); PURPOSELY OMITTED **/
    static void* operator new(size_t size, LinearAllocator& allocator) {
        return allocator.alloc(size);
    }

实现：

LinearAllocator主要用于多个对象需要重复申请，同时这些对象的生命周期都类似的情况。
实现原理即需要使用该内存分配的对象，需要使用new placement的方式，不需要自己申请内存，申请内存统一使用LinearAllocator来申请。在LinearAllocator内部分配了主要通过页的方式来申请内存，每页4kb，每页之间通过单链表的方式来组织。
1. 当需要申请内存时，判断当前页是否满足需要内存大小的申请。
2. 如果满足，则直接返回当前内存，将指针游标指向下一个内存开始。
3. 如果不满足，则需要重新申请一页大小的内存，将内存除了Page结构大小外的地址开始返回。
4. 如果需要，也可以在每个申请的内存之间加入一定的标记，用于内存的管理。

#pragma once

class LinearAllocator
{
public:
	LinearAllocator();
	~LinearAllocator();

	void* alloc(size_t size);

private:
	class Page;

	Page* newPage(size_t size);

	Page* mHeadPage;
	Page* mCurrentPage;
	void* mNext;
	size_t mMemoryCount;
};

#include <stdio.h>
#include <stdlib.h>
#include "LinearAllocator.h"

class LinearAllocator::Page
{
public:
	Page()
	{
		mNextPage = NULL;
	}

	~Page()
	{
	}

	void* operator new(size_t size, void* buf)
	{
		return buf;
	}
	
	//this is the memory begin, add the page size is 4, so the next is the real memory
	void* start()
	{		
		return (void*)((size_t)this + sizeof(Page));
	}

	void* end(size_t size)
	{
		return (char*)start() + size;
	}

	Page* mNextPage;
};

//page size is 4kb
const int ONE_PAGE_SIZE = 4096;
#define ALIGN_INT(x) (x + sizeof(int) -1) &~(sizeof(int) -1)

LinearAllocator::LinearAllocator()
{
	mHeadPage = mCurrentPage = NULL;
	mNext = NULL;
	mMemoryCount = 0;
}

//delete all the memory
LinearAllocator::~LinearAllocator()
{
	Page* p = mHeadPage;
	while(p)
	{
		Page* pNext = p->mNextPage;
		p->~Page();
		free(p);
		p = pNext;
	}
}

LinearAllocator::Page* LinearAllocator::newPage(size_t size)
{
	size_t allocSize = ALIGN_INT(sizeof(Page)+ size);
	mMemoryCount += allocSize;
	void* p = malloc(allocSize);
	return new(p) Page();
}

void* LinearAllocator::alloc(size_t size)
{
	size = ALIGN_INT(size);

	if (NULL == mHeadPage)
	{
		mHeadPage = mCurrentPage = newPage(ONE_PAGE_SIZE);
		mNext = mCurrentPage->start();
	}
	else if ((char*)mNext + size > mCurrentPage->end(ONE_PAGE_SIZE))
	{
		Page* p = newPage(ONE_PAGE_SIZE);
		mCurrentPage->mNextPage = p;
		mCurrentPage = p;
		mNext = mCurrentPage->start();
	}

	void* ptr = mNext;
	mNext = (char*)mNext + size;
	return ptr;
}

使用方式：

class AllocTest
{
public:
	AllocTest()
	{
		mCount ++;
		a = mCount;
		b = a+1;
		c = b+1;
	}
	void* operator new (size_t size, LinearAllocator& linearAlloc)
	{
		return linearAlloc.alloc(size);
	}

	void dump()
	{
		cout<<"a = "<<a<<"  b="<<b<<"  c="<<c<<endl;
	}

	int a;
	int b;
	int c;

	static int mCount;
};

int AllocTest::mCount = 0;

class LinearAllocTest
{
public:
	LinearAllocTest()
	{
		AllocTest* test1 = new(mLinearAlloc)AllocTest();
		AllocTest* test2 = new(mLinearAlloc)AllocTest();
		AllocTest* test3 = new(mLinearAlloc)AllocTest();
		AllocTest* test4 = new(mLinearAlloc)AllocTest();

		test1->dump();
		test2->dump
	}

	~LinearAllocTest()
	{

	}

private:
	LinearAllocator mLinearAlloc;
};

同时也可以参考Android源码：
system/core/include/utils/LinearAllocator.h