[Hgengine-cvs] SF.net SVN: hgengine:[761] Mercury2/src/MercuryMemory.h

[<axl...@us...>]

Revision: 761
          http://hgengine.svn.sourceforge.net/hgengine/?rev=761&view=rev
Author:   axlecrusher
Date:     2010-11-13 01:16:27 +0000 (Sat, 13 Nov 2010)

Log Message:
-----------
Remove new and delete from the memory manager.

Modified Paths:
--------------
    Mercury2/src/MercuryMemory.h

Modified: Mercury2/src/MercuryMemory.h
===================================================================
--- Mercury2/src/MercuryMemory.h	2010-11-12 21:00:56 UTC (rev 760)
+++ Mercury2/src/MercuryMemory.h	2010-11-13 01:16:27 UTC (rev 761)
@@ -14,67 +14,105 @@
 	free ride into the CPU cache. */
 	public:
 		MercuryMemory(const uint32_t rows)
-			:m_free(NULL),m_rows(rows)
+			:m_freeMem(NULL),m_freeUnit(NULL),m_rows(rows)
 		{
-			MSemaphoreLock lock(&m_lock);
+//			m_lock.Wait();
 			AllocateMoreSpace(m_rows);
+//			m_lock.UnLock();
 		}
 
 		T* Allocate()
 		{
 			T* m = NULL;
 			MemoryUnit* mu = NULL;
-			{
-				//keep really short lock
-				MSemaphoreLock lock(&m_lock);
-				if ( m_free == NULL ) AllocateMoreSpace(m_rows);
-				mu = m_free;
-				m_free=m_free->prev;
-				if (m_free!=mu->prev) { char* a = NULL; *a=0; } //wtf happened here!?!?! FREE CHANGED DURING OUR LOCK
-			}
-			m = mu->mem;
-			delete mu;
-			if (m==NULL) { char* a = NULL; *a=0; } //no memory allocated??
+			//keep really short lock
+			m_lock.Wait();
+			if ( m_freeMem == NULL ) m_freeMem = AllocateMoreSpace(m_rows);
+
+			//get record of free memory spot
+			mu = m_freeMem;
+			m_freeMem=m_freeMem->prev;
+			m = (T*)mu->mem;
+
+			SaveFreeUnit(mu);
+			m_lock.UnLock();
+//			delete mu;
+
+//			if (m==NULL) { char* a = NULL; *a=0; } //no memory allocated??
 			return m;
 		}
 
 		void Free(T* m)
 		{
-			MSemaphoreLock lock(&m_lock);
-			for (MemoryUnit* mu=m_free;mu!=NULL;mu=mu->prev)
-			{
+			m_lock.Wait();
+//			for (MemoryUnit* mu=m_freeMem;mu!=NULL;mu=mu->prev)
+//			{
 				//probably could some some sorting here to get contigious free and used memory
 				//if free memory is alwasy given out in order, then used memory will also be in order
-				if (m==mu->mem) { char* a=NULL;*a=0;} //WTF DOUBLE FREE
-			}
-			m_free = new MemoryUnit(m_free,m);
+//				if (m==mu->mem) { char* a=NULL;*a=0;} //WTF DOUBLE FREE
+//			}
+//			m_freeMem = new MemoryUnit(m_freeMem,m);
+
+/*
+			MemoryUnit* mu = m_freeUnit;
+			m_freeUnit = m_freeUnit->prev; //set top free unit to next free unit
+			//setup unit and add it to the top of the free memory
+			mu->prev = m_freeMem;
+			mu->mem = m;
+*/			TakeFreeUnit(m);
+
+			m_lock.UnLock();
 		}
 
 	private:
 		struct MemoryUnit
 		{
-			MemoryUnit(MemoryUnit* p, T* m)
+			MemoryUnit(MemoryUnit* p, void* m)
 				:mem(m),prev(p)
 			{
 //				if (p!=NULL) p->next = this;
 			}
-			T* mem;
+//			T* mem;
+			void* mem;
 			MemoryUnit* prev;
 		};
 
-		void AllocateMoreSpace(const uint32_t rows)
+		MemoryUnit* AllocateMoreSpace(const uint32_t rows)
 		{
+			MemoryUnit* mu = NULL;
+
 			AlignedBuffer<T>* d = new AlignedBuffer<T>();
 			d->Allocate(rows,16);
 
+			m_lock.Wait();
+			m_data.push_back(d);
+			m_lock.UnLock();
+
 			for (unsigned int i = 0; i < rows;i++)
-				m_free = new MemoryUnit(m_free,(d->Buffer())+i);
+				mu = new MemoryUnit(mu,(d->Buffer())+i);
+			return mu;
+		}
 
-			m_data.push_back(d);
+		inline void TakeFreeUnit(T* m)
+		{
+			MemoryUnit* mu = m_freeUnit;
+			m_freeUnit = m_freeUnit->prev; //set top free unit to next free unit
+			//setup unit and add it to the top of the free memory
+			mu->prev = m_freeMem;
+			mu->mem = m;
+			m_freeMem = mu;
 		}
 
+		void SaveFreeUnit(MemoryUnit* mu)
+		{
+			mu->mem = NULL;
+			mu->prev = m_freeUnit;
+			m_freeUnit = mu;
+		}
+
 		std::list< AlignedBuffer<T>* > m_data;
-		MemoryUnit* m_free;
+		MemoryUnit* m_freeMem; //Free template memory
+		MemoryUnit* m_freeUnit; //Free MemoryUnits, for when 
 
 		MSemaphore m_lock;
 		unsigned long m_rows;


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.