Add LinearAllocator (0a73f822) · Commits · e / os / android_frameworks_native

include/utils/LinearAllocator.h

0 → 100644

+97 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2012, The Android Open Source Project
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in the
		* documentation and/or other materials provided with the distribution.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
		* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
		* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*/

		#ifndef ANDROID_LINEARALLOCATOR_H
		#define ANDROID_LINEARALLOCATOR_H

		#include <stddef.h>

		namespace android {

		/**
		* A memory manager that internally allocates multi-kbyte buffers for placing objects in. It avoids
		* the overhead of malloc when many objects are allocated. It is most useful when creating many
		* small objects with a similar lifetime, and doesn't add significant overhead for large
		* allocations.
		*/
		class LinearAllocator {
		public:
		LinearAllocator();
		~LinearAllocator();

		/**
		* Reserves and returns a region of memory of at least size 'size', aligning as needed.
		* Typically this is used in an object's overridden new() method or as a replacement for malloc.
		*
		* The lifetime of the returned buffers is tied to that of the LinearAllocator. If calling
		* delete() on an object stored in a buffer is needed, it should be overridden to use
		* rewindIfLastAlloc()
		*/
		void* alloc(size_t size);

		/**
		* Attempt to deallocate the given buffer, with the LinearAllocator attempting to rewind its
		* state if possible. No destructors are called.
		*/
		void rewindIfLastAlloc(void* ptr, size_t allocSize);

		/**
		* Dump memory usage statistics to the log (allocated and wasted space)
		*/
		void dumpMemoryStats(const char* prefix = "");

		/**
		* The number of bytes used for buffers allocated in the LinearAllocator (does not count space
		* wasted)
		*/
		size_t usedSize() const { return mTotalAllocated - mWastedSpace; }

		private:
		LinearAllocator(const LinearAllocator& other);

		class Page;

		Page* newPage(size_t pageSize);
		bool fitsInCurrentPage(size_t size);
		void ensureNext(size_t size);
		void* start(Page *p);
		void* end(Page* p);

		size_t mPageSize;
		size_t mMaxAllocSize;
		void* mNext;
		Page* mCurrentPage;
		Page* mPages;

		// Memory usage tracking
		size_t mTotalAllocated;
		size_t mWastedSpace;
		size_t mPageCount;
		size_t mDedicatedPageCount;
		};

		}; // namespace android

		#endif // ANDROID_LINEARALLOCATOR_H

libs/utils/Android.mk

+5 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@ commonSources:= \
		FileMap.cpp \
		Flattenable.cpp \
		JenkinsHash.cpp \
		LinearAllocator.cpp \
		LinearTransform.cpp \
		Log.cpp \
		PropertyMap.cpp \
		@@ -112,6 +113,10 @@ ifeq ($(TARGET_OS),linux)
		LOCAL_LDLIBS += -lrt -ldl
		endif

		ifeq ($(TARGET_ARCH),mips)
		LOCAL_CFLAGS += -DALIGN_DOUBLE
		endif

		LOCAL_C_INCLUDES += \
		bionic/libc/private \
		external/zlib

libs/utils/LinearAllocator.cpp

0 → 100644

+227 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2012, The Android Open Source Project
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in the
		* documentation and/or other materials provided with the distribution.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
		* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
		* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*/

		#define LOG_TAG "LinearAllocator"
		#define LOG_NDEBUG 1

		#include <stdlib.h>
		#include <utils/LinearAllocator.h>
		#include <utils/Log.h>


		// The ideal size of a page allocation (these need to be multiples of 8)
		#define INITIAL_PAGE_SIZE ((size_t)4096) // 4kb
		#define MAX_PAGE_SIZE ((size_t)131072) // 128kb

		// The maximum amount of wasted space we can have per page
		// Allocations exceeding this will have their own dedicated page
		// If this is too low, we will malloc too much
		// Too high, and we may waste too much space
		// Must be smaller than INITIAL_PAGE_SIZE
		#define MAX_WASTE_SIZE ((size_t)1024)

		#if ALIGN_DOUBLE
		#define ALIGN_SZ (sizeof(double))
		#else
		#define ALIGN_SZ (sizeof(int))
		#endif

		#define ALIGN(x) ((x + ALIGN_SZ - 1 ) & ~(ALIGN_SZ - 1))
		#define ALIGN_PTR(p) ((void*)(ALIGN((size_t)p)))

		#if LOG_NDEBUG
		#define ADD_ALLOCATION(size)
		#define RM_ALLOCATION(size)
		#else
		#include <utils/Thread.h>
		#include <utils/Timers.h>
		static size_t s_totalAllocations = 0;
		static nsecs_t s_nextLog = 0;
		static android::Mutex s_mutex;

		static void _logUsageLocked() {
		nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
		if (now > s_nextLog) {
		s_nextLog = now + milliseconds_to_nanoseconds(10);
		ALOGV("Total memory usage: %zu kb", s_totalAllocations / 1024);
		}
		}

		static void _addAllocation(size_t size) {
		android::AutoMutex lock(s_mutex);
		s_totalAllocations += size;
		_logUsageLocked();
		}

		#define ADD_ALLOCATION(size) _addAllocation(size);
		#define RM_ALLOCATION(size) _addAllocation(-size);
		#endif

		#define min(x,y) (((x) < (y)) ? (x) : (y))

		namespace android {

		class LinearAllocator::Page {
		public:
		Page* next() { return mNextPage; }
		void setNext(Page* next) { mNextPage = next; }

		Page()
		: mNextPage(0)
		{}

		void* operator new(size_t size, void* buf) { return buf; }

		void* start() {
		return (void*) (((size_t)this) + sizeof(Page));
		}

		void* end(int pageSize) {
		return (void*) (((size_t)start()) + pageSize);
		}

		private:
		Page(const Page& other) {}
		Page* mNextPage;
		};

		LinearAllocator::LinearAllocator()
		: mPageSize(INITIAL_PAGE_SIZE)
		, mMaxAllocSize(MAX_WASTE_SIZE)
		, mNext(0)
		, mCurrentPage(0)
		, mPages(0)
		, mTotalAllocated(0)
		, mWastedSpace(0)
		, mPageCount(0)
		, mDedicatedPageCount(0) {}

		LinearAllocator::~LinearAllocator(void) {
		Page* p = mPages;
		while (p) {
		Page* next = p->next();
		p->~Page();
		free(p);
		RM_ALLOCATION(mPageSize);
		p = next;
		}
		}

		void* LinearAllocator::start(Page* p) {
		return ALIGN_PTR(((size_t*)p) + sizeof(Page));
		}

		void* LinearAllocator::end(Page* p) {
		return ((char*)p) + mPageSize;
		}

		bool LinearAllocator::fitsInCurrentPage(size_t size) {
		return mNext && ((char*)mNext + size) <= end(mCurrentPage);
		}

		void LinearAllocator::ensureNext(size_t size) {
		if (fitsInCurrentPage(size)) return;

		if (mCurrentPage && mPageSize < MAX_PAGE_SIZE) {
		mPageSize = min(MAX_PAGE_SIZE, mPageSize * 2);
		mPageSize = ALIGN(mPageSize);
		}
		mWastedSpace += mPageSize;
		Page* p = newPage(mPageSize);
		if (mCurrentPage) {
		mCurrentPage->setNext(p);
		}
		mCurrentPage = p;
		if (!mPages) {
		mPages = mCurrentPage;
		}
		mNext = start(mCurrentPage);
		}

		void* LinearAllocator::alloc(size_t size) {
		size = ALIGN(size);
		if (size > mMaxAllocSize && !fitsInCurrentPage(size)) {
		ALOGV("Exceeded max size %zu > %zu", size, mMaxAllocSize);
		// Allocation is too large, create a dedicated page for the allocation
		Page* page = newPage(size);
		mDedicatedPageCount++;
		page->setNext(mPages);
		mPages = page;
		if (!mCurrentPage)
		mCurrentPage = mPages;
		return start(page);
		}
		ensureNext(size);
		void* ptr = mNext;
		mNext = ((char*)mNext) + size;
		mWastedSpace -= size;
		return ptr;
		}

		void LinearAllocator::rewindIfLastAlloc(void* ptr, size_t allocSize) {
		// Don't bother rewinding across pages
		allocSize = ALIGN(allocSize);
		if (ptr >= start(mCurrentPage) && ptr < end(mCurrentPage)
		&& ptr == ((char*)mNext - allocSize)) {
		mTotalAllocated -= allocSize;
		mWastedSpace += allocSize;
		mNext = ptr;
		}
		}

		LinearAllocator::Page* LinearAllocator::newPage(size_t pageSize) {
		pageSize = ALIGN(pageSize + sizeof(LinearAllocator::Page));
		ADD_ALLOCATION(pageSize);
		mTotalAllocated += pageSize;
		mPageCount++;
		void* buf = malloc(pageSize);
		return new (buf) Page();
		}

		static const char* toSize(size_t value, float& result) {
		if (value < 2000) {
		result = value;
		return "B";
		}
		if (value < 2000000) {
		result = value / 1024.0f;
		return "KB";
		}
		result = value / 1048576.0f;
		return "MB";
		}

		void LinearAllocator::dumpMemoryStats(const char* prefix) {
		float prettySize;
		const char* prettySuffix;
		prettySuffix = toSize(mTotalAllocated, prettySize);
		ALOGD("%sTotal allocated: %.2f%s", prefix, prettySize, prettySuffix);
		prettySuffix = toSize(mWastedSpace, prettySize);
		ALOGD("%sWasted space: %.2f%s (%.1f%%)", prefix, prettySize, prettySuffix,
		(float) mWastedSpace / (float) mTotalAllocated * 100.0f);
		ALOGD("%sPages %zu (dedicated %zu)", prefix, mPageCount, mDedicatedPageCount);
		}

		}; // namespace android