int CMemory::RemoveElements(CArrayVoidPtr* pav, int i, SFNode* psNode, CFreeList* pcList)
{
void* pv;
SMemoryAllocation* psFirst;
SMemoryAllocation* psLast;
int iCount;
SMemoryAllocation* psAlloc;
int iNumElements;
iNumElements = pav->NumElements();
psFirst = (SMemoryAllocation*)pcList->GetFirstNodeElement(psNode);
psLast = (SMemoryAllocation*)pcList->GetLastNodeElement(psNode);
iCount = 0;
pv = pav->GetPtr(i);
psAlloc = MEMORY_GET_ALLOCATION(pv);
while (psAlloc <= psLast)
{
pcList->Remove(psNode, psAlloc);
i++;
iCount++;
if (i >= iNumElements)
{
break;
}
pv = pav->GetPtr(i);
psAlloc = MEMORY_GET_ALLOCATION(pv);
}
return iCount;
}
void CUnknowns::DumpAddDetail(CUnknown* pcUnknown)
{
SMemoryAllocation* psAlloc;
CChars sz;
psAlloc = MEMORY_GET_ALLOCATION(pcUnknown);
if (!IsFreed(pcUnknown))
{
sz.Init("Size: ");
sz.Append(psAlloc->uiSize);
sz.AppendNewLine();
sz.Append("AllocCount: ");
sz.Append(psAlloc->uiAllocCount);
sz.AppendNewLine();
sz.Append("DebugName: ");
sz.Append(psAlloc->szDebug, 4);
sz.AppendNewLine();
sz.Dump();
sz.Kill();
}
else
{
sz.Init("Freed CUnknown.\n");
sz.Append("AllocCount: ");
sz.Append(psAlloc->uiAllocCount);
sz.AppendNewLine();
sz.Dump();
sz.Kill();
}
}
unsigned int CMemory::GetSize(void* pv)
{
SMemoryAllocation* psAlloc;
psAlloc = MEMORY_GET_ALLOCATION(pv);
return psAlloc->uiSize;
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
void CMemory::SetDebugName(void* pv, char (*pszDebug)[4])
{
SMemoryAllocation* psAlloc;
psAlloc = MEMORY_GET_ALLOCATION(pv);
psAlloc->szDebug[0] = (*pszDebug)[0];
psAlloc->szDebug[1] = (*pszDebug)[1];
psAlloc->szDebug[2] = (*pszDebug)[2];
psAlloc->szDebug[3] = (*pszDebug)[3];
}
BOOL CMemory::Remove(CArrayVoidPtr* pav)
{
int i;
void* pv;
SMemoryAllocation* psAlloc;
CFreeList* pcList;
SFNode* psNode;
int iNumElements;
int iChunkSize;
int iRemoved;
pav->QuickSort();
iNumElements = pav->NumElements();
i = 0;
while (i < iNumElements)
{
pv = pav->GetPtr(i);
psAlloc = MEMORY_GET_ALLOCATION(pv);
if (psAlloc->uiSize <= (muiFreeListSizeLimit - sizeof(SMemoryAllocation)))
{
psNode = psAlloc->psFreeListNode;
pcList = (CFreeList*)psAlloc->psFreeListNode->pcList;
iChunkSize = pcList->GetChunkSize();
iRemoved = RemoveNode(pav, i, psAlloc, iChunkSize, psNode, pcList);
if (iRemoved != 0)
{
i += iRemoved;
}
else
{
iRemoved = RemoveElements(pav, i, psNode, pcList);
if (iRemoved != 0)
{
i += iRemoved;
}
else
{
gcLogger.Error2(__METHOD__, " Could not deallocate memory.", NULL);
return FALSE;
}
}
}
else
{
DeallocateInLargeList(psAlloc);
}
}
return TRUE;
}
void* CMemory::Grow(void* pvInitial, unsigned int uiSize)
{
SMemoryAllocation* psAlloc;
CFreeList* pcList;
SMemoryFreeListParams* psParams;
void* pvNew;
SLLANode* psNode;
psAlloc = MEMORY_GET_ALLOCATION(pvInitial);
if (psAlloc->uiSize <= (muiFreeListSizeLimit - sizeof(SMemoryAllocation)))
{
psParams = GetFreeListParamsForSize(psAlloc->uiSize);
if ((uiSize <= psParams->iMaxElementSize) && (uiSize >= psParams->iMinElementSize))
{
psAlloc->uiSize = uiSize;
return pvInitial;
}
else
{
pcList = (CFreeList*)psAlloc->psFreeListNode->pcList;
pvNew = Add(uiSize, pcList->GetAlignment(), pcList->GetOffset());
CopyAllocation(pvNew, pvInitial, uiSize, psAlloc->uiSize);
DeallocateInFreeList(pcList, psAlloc);
return pvNew;
}
}
else
{
psNode = (SLLANode*)RemapSinglePointer(psAlloc, -((int)sizeof(SLLANode)));
if (uiSize <= (muiFreeListSizeLimit - sizeof(SMemoryAllocation)))
{
pvNew = Add(uiSize, psNode->sAligned.iAlignment, psNode->sAligned.iOffset);
CopyAllocation(pvNew, pvInitial, uiSize, psAlloc->uiSize);
DeallocateInLargeList(psAlloc);
return pvNew;
}
else
{
psAlloc = (SMemoryAllocation*)mcLargeList.Grow(psAlloc, uiSize);
psAlloc->uiSize = uiSize;
psAlloc->psFreeListNode = NULL;
pvNew = RemapSinglePointer(psAlloc, sizeof(SMemoryAllocation));
return pvNew;
}
}
}
void CMemory::Remove(void* pv)
{
SMemoryAllocation* psAlloc;
CFreeList* pcList;
psAlloc = MEMORY_GET_ALLOCATION(pv);
if (psAlloc->uiSize <= (muiFreeListSizeLimit - sizeof(SMemoryAllocation)))
{
pcList = (CFreeList*)psAlloc->psFreeListNode->pcList;
DeallocateInFreeList(pcList, psAlloc);
}
else
{
DeallocateInLargeList(psAlloc);
}
}
int CMemory::RemoveNode(CArrayVoidPtr* pav, int i, SMemoryAllocation* psAlloc, int iChunkSize, SFNode* psNode, CFreeList* pcList)
{
void* pvLast;
SMemoryAllocation* psPotentialLast;
int iNodeElements;
SMemoryAllocation* psFirst;
SMemoryAllocation* psLast;
int iNumElements;
iNumElements = pav->NumElements();
psFirst = (SMemoryAllocation*)pcList->GetFirstNodeElement(psNode);
if (psAlloc == psFirst)
{
psLast = (SMemoryAllocation*)pcList->GetLastNodeElement(psNode);
if (psNode->bFull)
{
iNodeElements = iChunkSize;
}
else
{
iNodeElements = pcList->NumNodeElements(psNode);
}
if (i + iNodeElements - 1 < iNumElements)
{
pvLast = pav->GetPtr(i + iNodeElements - 1);
psPotentialLast = MEMORY_GET_ALLOCATION(pvLast);
if (psPotentialLast == psLast)
{
pcList->RemoveNode(psNode);
return iNodeElements;
}
}
}
return 0;
}
BOOL CUnknowns::IsFreed(CUnknown* pcUnknown)
{
#ifdef _DEBUG
SMemoryAllocation* psAlloc;
int i;
int* piMem;
psAlloc = MEMORY_GET_ALLOCATION(pcUnknown);
for (i = 1; i < sizeof(SMemoryAllocation)/4; i++)
{
piMem = &((int*)psAlloc)[i];
if (*piMem != 0xefefefef)
{
return FALSE;
}
}
return TRUE;
#else // _DEBUG;
//Actually we don't know.
return FALSE;
#endif // _DEBUG;
}
