+Unity Runtime codeHEADmaster

1 files changed, 618 insertions, 0 deletions

diff --git a/Runtime/mecanim/memory.h b/Runtime/mecanim/memory.h
new file mode 100644
index 0000000..5331051
--- /dev/null
+++ b/Runtime/mecanim/memory.h
@@ -0,0 +1,618 @@
+#pragma once
+
+#include "Runtime/mecanim/defs.h"
+#include "Runtime/mecanim/types.h"
+#include "Runtime/Utilities/dynamic_array.h"
+#include "Runtime/Utilities/FileUtilities.h"
+
+#include "Runtime/Allocator/MemoryManager.h"
+
+#include <assert.h>
+#include <new>
+
+#if ENABLE_MECANIM_PROFILER
+#include <fstream>
+#include <stack>
+#include <string.h>
+#include <stdlib.h>
+#include <ctime>
+#endif
+
+template <typename TYPE> class OffsetPtr;
+
+namespace mecanim
+{
+
+namespace memory
+{	
+#if ENABLE_MECANIM_PROFILER
+	class Profiler
+	{
+	public:
+
+		struct AllocationInfo
+		{
+			AllocationInfo():m_Size(0),m_Allocator("Unknow"){}
+			AllocationInfo(size_t size, char const* allocator):m_Size(size),m_Allocator(allocator){}
+			bool operator==(AllocationInfo const& allocationInfo)const
+			{
+				return m_Size == allocationInfo.m_Size && strcmp(m_Allocator, allocationInfo.m_Allocator) == 0;
+			}
+			size_t	m_Size;
+			char const* m_Allocator;
+		};
+
+
+		typedef std::map<void*, AllocationInfo> AllocationInfos; 
+		struct ProfilerLabel
+		{
+			ProfilerLabel():m_Label("Unknow"), m_ExclusiveSize(0),m_InclusiveSize(0),m_Parent(0),m_Count(0){}
+			ProfilerLabel(char const* labelId):m_Label(labelId), m_ExclusiveSize(0),m_InclusiveSize(0),m_Parent(0),m_Count(0){}
+			~ProfilerLabel()
+			{
+				for(int i=0;i<m_Children.size();i++)
+				{
+					m_Children[i]->~ProfilerLabel();
+					MemoryManager::LowLevelFree(m_Children[i]);
+				}
+
+				m_Children.clear();
+			}
+
+			char const*		m_Label;
+			size_t			m_ExclusiveSize;
+			size_t			m_InclusiveSize;
+			size_t			m_Count;
+			AllocationInfos	m_Allocations;
+
+			ProfilerLabel*				m_Parent;
+			std::vector<ProfilerLabel*>	m_Children;
+		};
+
+		Profiler():m_Root("Root"){}
+		~Profiler(){}
+
+		static void StaticInitialize()
+		{
+			s_Profiler = UNITY_NEW(Profiler, kMemDefault)();
+			s_Profiler->m_Current = &s_Profiler->m_Root;
+		}
+
+		static void StaticDestroy()
+		{
+			UNITY_DELETE(s_Profiler, kMemDefault);
+		}
+
+		void PushLabel(char const * label)
+		{ 
+			m_LabelStack.push(label);
+			LabelMap::iterator it = m_Label.find(label);
+			if(it == m_Label.end())
+				it = m_Label.insert( std::make_pair(label, ProfilerLabel(label) ) ).first;
+			
+			AssertIf(it == m_Label.end());
+			it->second.m_Count++;
+
+			s_Profiler->m_Current->m_Children.push_back( new (MemoryManager::LowLevelAllocate(sizeof(ProfilerLabel))) ProfilerLabel(label) );
+			ProfilerLabel* newLabel = s_Profiler->m_Current->m_Children.back();
+			newLabel->m_Parent = s_Profiler->m_Current;
+			s_Profiler->m_Current = newLabel;
+		}
+
+		void PopLabel()
+		{
+			m_LabelStack.pop();
+
+			ProfilerLabel* parentLabel = s_Profiler->m_Current->m_Parent;
+
+			// If not a single allocation had been made, remove it
+			if(s_Profiler->m_Current->m_Allocations.size() == 0 && s_Profiler->m_Current->m_Children.size() == 0)
+			{
+				parentLabel->m_Children[parentLabel->m_Children.size()-1]->~ProfilerLabel();
+				MemoryManager::LowLevelFree(parentLabel->m_Children[parentLabel->m_Children.size()-1]);
+
+				parentLabel->m_Children.resize( parentLabel->m_Children.size()-1 );
+			}
+			
+			s_Profiler->m_Current = parentLabel;
+
+			assert(s_Profiler->m_Current != NULL);
+		}
+
+		void RegisterAllocation(void* ptr, char const* alloc, size_t size = 0)
+		{
+			AssertIf(m_LabelStack.empty());
+			char const* label = m_LabelStack.empty() ? "Unknow" : m_LabelStack.top();
+
+			std::map<char const*, ProfilerLabel>::iterator it = m_Label.find(label);
+			if(it == m_Label.end())
+				m_Label.insert( std::make_pair(label, ProfilerLabel(label) ) );
+
+			m_Label[label].m_Allocations.insert( std::make_pair(ptr, AllocationInfo(size, alloc) ) );
+			m_Label[label].m_ExclusiveSize += size;
+
+			s_Profiler->m_Current->m_Allocations.insert( std::make_pair(ptr, AllocationInfo(size, alloc) ) );
+			s_Profiler->m_Current->m_ExclusiveSize += size;
+			s_Profiler->m_Current->m_InclusiveSize += size;
+
+			ProfilerLabel* profilerLabel = s_Profiler->m_Current->m_Parent;
+			while(profilerLabel!=NULL)
+			{
+				profilerLabel->m_InclusiveSize += size;
+				profilerLabel = profilerLabel->m_Parent;
+			}
+
+			m_PointerRegister.insert( std::make_pair(ptr, std::make_pair( &m_Label[label], s_Profiler->m_Current)));
+		}
+
+		void UnregisterAllocation(void* ptr)
+		{
+			if(ptr == NULL)
+				return;
+
+			PointerRegister::iterator it = m_PointerRegister.find(ptr);
+
+			assert(it!=m_PointerRegister.end());
+
+			if(it!=m_PointerRegister.end())
+			{
+				ProfilerLabel* label = it->second.first;
+				AllocationInfos::iterator itAlloc = label->m_Allocations.find(ptr);
+				if(itAlloc!=label->m_Allocations.end())
+				{
+					label->m_ExclusiveSize -= itAlloc->second.m_Size;
+					label->m_Allocations.erase(itAlloc);
+					if(label->m_Allocations.size() == 0 )
+						m_Label.erase( m_Label.find(label->m_Label) );
+				}
+
+				label = it->second.second;
+				itAlloc = label->m_Allocations.find(ptr);
+				if(itAlloc != label->m_Allocations.end())
+				{
+					size_t size = itAlloc->second.m_Size;
+					label->m_ExclusiveSize -= size;
+					label->m_InclusiveSize -= size;
+					label->m_Allocations.erase(itAlloc);
+
+					ProfilerLabel* parentLabel = label->m_Parent;
+					
+					if(parentLabel != NULL && label->m_Allocations.size() == 0 && label->m_Children.size() == 0)
+					{
+						parentLabel->m_Children.erase( std::find(parentLabel->m_Children.begin(), parentLabel->m_Children.end(), label ));
+						label->~ProfilerLabel();
+						MemoryManager::LowLevelFree(label);
+					}
+					
+					while(parentLabel!=NULL)
+					{
+						label = parentLabel;
+						parentLabel = label->m_Parent;
+
+						label->m_InclusiveSize -= size;
+						if(parentLabel != NULL && label->m_Allocations.size() == 0 && label->m_Children.size() == 0)
+						{
+							parentLabel->m_Children.erase( std::find(parentLabel->m_Children.begin(), parentLabel->m_Children.end(), label ));
+							label->~ProfilerLabel();
+							MemoryManager::LowLevelFree(label);
+						}
+					}
+				}
+
+				m_PointerRegister.erase(it);
+			}
+		}
+
+		static Profiler* GetProfiler()
+		{
+			return s_Profiler;
+		}
+
+		void DumpObjectTypeMemoryInfo()
+		{
+			time_t rawtime;
+			struct tm * timeinfo;
+
+			time (&rawtime);
+			timeinfo = localtime (&rawtime);
+
+			string tempDir = Format("%s/ObjectTypeMemoryInfo_%.2d_%.2d_%.2d_%.2dh%.2dm%.2ds.csv", 
+									GetApplicationFolder().c_str(), 
+									1900 + timeinfo->tm_year, 
+									timeinfo->tm_mon, 
+									timeinfo->tm_mday,
+									timeinfo->tm_hour,
+									timeinfo->tm_min,
+									timeinfo->tm_sec);
+			std::ofstream file(tempDir);
+
+			file << "Object, Size, Count, Allocation Count" << std::endl;
+
+			LabelMap::iterator it;
+			for(it=m_Label.begin();it!=m_Label.end();it++)
+				file << it->second.m_Label << "," << it->second.m_ExclusiveSize << "," << it->second.m_Count << "," << it->second.m_Allocations.size() << std::endl;
+
+			file.close();
+		}
+
+		void DumpCallSiteMemoryInfo()
+		{
+			time_t rawtime;
+			struct tm * timeinfo;
+
+			time (&rawtime);
+			timeinfo = localtime (&rawtime);
+
+			string tempDir = Format("%s/CallSiteMemoryInfo_%.2d_%.2d_%.2d_%.2dh%.2dm%.2ds.csv", 
+									GetApplicationFolder().c_str(), 
+									1900 + timeinfo->tm_year, 
+									timeinfo->tm_mon, 
+									timeinfo->tm_mday,
+									timeinfo->tm_hour,
+									timeinfo->tm_min,
+									timeinfo->tm_sec);
+			//std::ofstream file(tempDir);
+			//file.close();
+		}
+		
+	protected:
+		static Profiler* s_Profiler;
+
+		std::stack<char const*> 		        m_LabelStack;
+
+		typedef std::map<char const*, ProfilerLabel> LabelMap;
+		LabelMap	m_Label;
+
+		typedef std::map<void *, std::pair<ProfilerLabel*, ProfilerLabel*> > PointerRegister;
+		PointerRegister	m_PointerRegister;
+
+		ProfilerLabel							m_Root;
+		ProfilerLabel*							m_Current;
+	};
+#else
+	class Profiler
+	{
+	public:Profiler(){}
+		~Profiler(){}
+
+		static void StaticInitialize()
+		{
+			s_Profiler = UNITY_NEW(Profiler, kMemDefault)();
+		}
+
+		static void StaticDestroy()
+		{
+			UNITY_DELETE(s_Profiler, kMemDefault);
+		}
+
+		void PushLabel(char const * label){ }
+
+		void PopLabel(){}
+
+		void RegisterAllocation(void* ptr, char const* alloc, size_t size = 0){	}
+
+		void UnregisterAllocation(void* ptr){}
+
+		void DumpObjectTypeMemoryInfo(){}
+
+		void DumpCallSiteMemoryInfo(){}
+
+		static Profiler* GetProfiler()
+		{
+			return s_Profiler;
+		}
+	protected:
+		static Profiler* s_Profiler;
+	};
+#endif
+
+	class AutoScopeProfiler
+	{
+	public:
+		AutoScopeProfiler(char const* label) { Profiler::GetProfiler()->PushLabel(label); }
+		~AutoScopeProfiler() { Profiler::GetProfiler()->PopLabel();}
+	};
+
+	#define SETPROFILERLABEL(type) mecanim::memory::AutoScopeProfiler scopeProfiler##type(#type) 
+
+	class Allocator
+	{
+	public:
+		std::size_t	AlignAddress(std::size_t aAddr, std::size_t aAlign)
+		{
+			return aAddr + ((~aAddr + 1U) & (aAlign - 1U));
+		}
+		
+		virtual void*		Allocate(std::size_t size, std::size_t align) = 0 ;
+		virtual void		Deallocate(void * p) = 0;		
+
+		template <typename TYPE>
+		TYPE* Construct(std::size_t align = ALIGN_OF(TYPE))
+		{
+			
+			char *ptr = reinterpret_cast<char *>(Allocate(sizeof(TYPE), align));	
+			return new( (void *) ptr) TYPE;
+		}
+
+		template <typename TYPE>
+		TYPE* ConstructArray(std::size_t count, std::size_t align = ALIGN_OF(TYPE))
+		{
+			if(count > 0)
+			{
+				char *ptr = reinterpret_cast<char *>(Allocate(sizeof(TYPE)*count, align));
+				return new( (void *) ptr) TYPE[count];
+			}
+			else
+			{
+				return 0;
+			}
+		}
+
+		template <typename TYPE>
+		TYPE* ConstructArray(const TYPE* input, std::size_t count, std::size_t align = ALIGN_OF(TYPE))
+		{
+			if(count > 0)
+			{
+				TYPE *ptr = reinterpret_cast<TYPE*> (Allocate(sizeof(TYPE)*count, align));
+				memcpy(ptr, input, sizeof(TYPE)*count);
+				return ptr;
+			}
+			else
+			{
+				return 0;
+			}
+		}
+		
+		template <typename TYPE>
+		void Deallocate(OffsetPtr<TYPE>& p)
+		{
+			if(!p.IsNull())
+				Deallocate(p.Get());
+		}
+	};
+
+	// Should be constructed with either:
+	//		kMemAnimation
+	//		kMemAnimationTemp
+	class MecanimAllocator : public Allocator
+	{
+		MemLabelId m_Label;
+	protected:
+		MecanimAllocator(MecanimAllocator const& e):Allocator(){ m_Label = e.m_Label; m_Label.SetRootHeader(GET_CURRENT_ALLOC_ROOT_HEADER());}
+		MecanimAllocator& operator=(MecanimAllocator const &){ return *this; }		
+	public:
+		MecanimAllocator(MemLabelId label):m_Label(label){ m_Label.SetRootHeader(GET_CURRENT_ALLOC_ROOT_HEADER());}
+
+		virtual void* Allocate(std::size_t size, std::size_t align)
+		{
+			void* p = UNITY_MALLOC_ALIGNED(m_Label, size, align);
+
+			Profiler::GetProfiler()->RegisterAllocation(p, "MecanimAllocator", size);
+
+			return p;
+		}
+
+		virtual void Deallocate(void * p)
+		{
+			Profiler::GetProfiler()->UnregisterAllocation(p);
+			UNITY_FREE(m_Label, p);
+		}
+	};
+
+	class InPlaceAllocator : public Allocator
+	{
+	protected:
+		char* mP;
+		char* mHead;
+		std::size_t mMaxSize;
+		InPlaceAllocator(InPlaceAllocator const &):Allocator(){}
+		InPlaceAllocator& operator=(InPlaceAllocator const &){ return *this; }
+	public:
+		
+		
+		InPlaceAllocator(void *p, std::size_t aSize):mP(reinterpret_cast<char *>(p)),mHead(reinterpret_cast<char *>(p)), mMaxSize(aSize){};
+
+//		InPlaceAllocator(size_t size, MemoryLabelId label)
+//		{
+//			mHead = mP = UNITY_MALLOC_ALIGNED(label, size, 16);
+//			mMaxSize = aSize;
+//			
+//		}
+		
+		~InPlaceAllocator() { }
+
+		inline std::size_t TotalMemorySize()const  { return mMaxSize; }
+		inline std::size_t UsedMemorySize()const   { return reinterpret_cast<std::size_t>(mP) - reinterpret_cast<std::size_t>(mHead); }
+		inline std::size_t FreeMemorySize()const   { return TotalMemorySize() - UsedMemorySize(); }
+
+		void* GetMemory ()
+		{
+			return mP;
+		}
+		
+		virtual void* Allocate(std::size_t n, std::size_t align)
+		{	
+			char *p = reinterpret_cast<char *>(AlignAddress(reinterpret_cast<std::size_t>(mP), align));
+			
+			// The first allocation must always be aligned already
+			AssertIf(mHead == mP && p != mHead);
+			
+			// assert(p+n <= mHead+mMaxSize);			
+				
+			if(p+n <= mHead+mMaxSize)
+			{
+				mP = p+n;
+				return reinterpret_cast<void *>(p);
+			}
+			else
+			{
+				return 0;
+			}
+		}
+
+		virtual void Deallocate(void * p)
+		{	
+			AssertString("Not supported");
+		}
+	};
+
+	class ChainedAllocator : public Allocator
+	{
+		ProfilerAllocationHeader* rootHeader;
+	protected:
+
+		enum {
+			BlockAlign = 16
+		};
+
+		struct MemoryBlock {
+			MemoryBlock*	next;
+			uint8_t*		headPtr;
+			std::size_t		blockSize;
+		};
+
+		ChainedAllocator(ChainedAllocator const&):Allocator(){rootHeader = GET_CURRENT_ALLOC_ROOT_HEADER();}
+		ChainedAllocator& operator=(ChainedAllocator const &){ return *this; }
+		
+		std::size_t GetMemBlockSize(std::size_t aSize, std::size_t aAlign)
+		{
+			return sizeof(MemoryBlock) + aSize + aAlign - 1U;
+		}
+
+		std::size_t GetAllocateSize(std::size_t aSize, std::size_t aAlign)
+		{
+			return aSize + aAlign - 1U;
+		}
+
+		MemoryBlock* first;
+		MemoryBlock* current;
+		uint8_t*	 heapPtr;
+		std::size_t  blockSize;
+	public:
+		ChainedAllocator(std::size_t aBlockSize):first(0),current(0),blockSize(aBlockSize)
+		{
+			rootHeader = GET_CURRENT_ALLOC_ROOT_HEADER();
+		}
+
+		~ChainedAllocator()
+		{
+			Reset();			
+		}
+
+		void Init()
+		{
+			if(first == 0)
+			{
+				size_t size = GetMemBlockSize(blockSize, BlockAlign);
+				void *p = UNITY_MALLOC(MemLabelId(kMemAnimationId,rootHeader),  size);
+				Profiler::GetProfiler()->RegisterAllocation(p, "ChainedAllocator", size);
+				if(p)
+				{
+					current = first = new(p) MemoryBlock;
+					current->next = 0;
+					current->blockSize = blockSize;
+
+					uint8_t* head = reinterpret_cast<uint8_t*>(p);
+					heapPtr = current->headPtr = reinterpret_cast<uint8_t*>( AlignAddress( reinterpret_cast<std::size_t>(head + sizeof(MemoryBlock)), BlockAlign));				
+				}
+			}
+		}
+
+		void Reset()
+		{
+			MemoryBlock* c = first;
+			while(c != 0)
+			{
+				void* p = reinterpret_cast<void*>(c);
+				c = c->next;
+				Profiler::GetProfiler()->UnregisterAllocation(p);
+				UNITY_FREE(kMemAnimation, p);
+			}
+			current = first = 0;
+			heapPtr = 0;
+		}
+
+		void Reserve(std::size_t size)
+		{
+			if(size > 0)
+			{
+				if(first == 0)
+				{
+					size_t size1 = GetMemBlockSize(size, BlockAlign);
+					void *p = UNITY_MALLOC(MemLabelId(kMemAnimationId,rootHeader),  size1);
+					Profiler::GetProfiler()->RegisterAllocation(p, "ChainedAllocator", size1);
+
+					if(p)
+					{
+						current = first = new(p) MemoryBlock;
+						current->next = 0;
+						current->blockSize = size;
+
+						uint8_t* head = reinterpret_cast<uint8_t*>(p);
+						heapPtr = current->headPtr = reinterpret_cast<uint8_t*>( AlignAddress( reinterpret_cast<std::size_t>(head + sizeof(MemoryBlock)), BlockAlign));				
+					}
+				}
+				else
+				{
+					size_t size1 = GetMemBlockSize(size, BlockAlign);
+					void *p = UNITY_MALLOC(MemLabelId(kMemAnimationId,rootHeader),  size1);
+					Profiler::GetProfiler()->RegisterAllocation(p, "ChainedAllocator", size1);
+					if(p)
+					{
+						current->next = new(p) MemoryBlock;
+						current = current->next;
+						current->next = 0;
+						current->blockSize = size > blockSize ? size : blockSize;
+
+						uint8_t* head = reinterpret_cast<uint8_t*>(p);					
+						heapPtr = current->headPtr = reinterpret_cast<uint8_t*>( AlignAddress( reinterpret_cast<std::size_t>(head + sizeof(MemoryBlock)), BlockAlign));
+					}
+				}
+			}
+		}
+
+		// Limit case are
+		//	no memory left in current block, allocate a new block
+		//  no memory left in system, bail out
+		virtual void* Allocate(std::size_t size, std::size_t align)
+		{
+			Init();
+
+			std::size_t s = GetAllocateSize(size, align);
+
+			// Not enough memory left in current block, allocate a new block
+			if( heapPtr + s > current->headPtr + current->blockSize)
+			{
+				// If not enough memory left in system, bail out
+				// If the requested size is bigger than the block size, allocate at least a block big enough for this request.
+				size_t size1 = GetMemBlockSize(size > blockSize ? size : blockSize, BlockAlign);
+				void *p = UNITY_MALLOC(MemLabelId(kMemAnimationId,rootHeader),  size1);
+				Profiler::GetProfiler()->RegisterAllocation(p, "ChainedAllocator", size1);
+				if(p)
+				{
+					current->next = new(p) MemoryBlock;
+					current = current->next;
+					current->next = 0;
+					current->blockSize = size > blockSize ? size : blockSize;
+
+					uint8_t* head = reinterpret_cast<uint8_t*>(p);					
+					heapPtr = current->headPtr = reinterpret_cast<uint8_t*>( AlignAddress( reinterpret_cast<std::size_t>(head + sizeof(MemoryBlock)), BlockAlign));
+				}
+				else
+					return 0;
+			}
+
+			uint8_t *p = reinterpret_cast<uint8_t *>(AlignAddress(reinterpret_cast<std::size_t>(heapPtr), align));				
+			heapPtr = p+size;
+			return reinterpret_cast<void *>(p);			
+		}
+
+		virtual void Deallocate(void * p)
+		{
+			assert(true);
+		}
+	};
+
+}
+
+}