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.
|
