/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#include "CMemoryPoolAllocationManager.h"
namespace Konclude {
namespace Utilities {
namespace Memory {
CMemoryPoolAllocationManager::CMemoryPoolAllocationManager(CMemoryPoolProvider* memoryPoolProvider) {
mMemoryPoolProvider = memoryPoolProvider;
mFreeMemoryPoolList = nullptr;
mUsedMemoryPoolList = nullptr;
mUsingMemoryPool = nullptr;
mFreeMemoryPoolCount = 0;
mStatMemToUsingCount = 0;
mStatMemToFreeCount = 0;
}
CMemoryPoolAllocationManager::~CMemoryPoolAllocationManager() {
// release all memory blocks
while (mFreeMemoryPoolList) {
CMemoryPool* tmpMemPool = mFreeMemoryPoolList;
mFreeMemoryPoolList = mFreeMemoryPoolList->getNextMemoryPool();
tmpMemPool->clearNext();
mMemoryPoolProvider->releaseMemoryPool(tmpMemPool);
}
while (mUsedMemoryPoolList) {
CMemoryPool* tmpMemPool = mUsedMemoryPoolList;
mUsedMemoryPoolList = mUsedMemoryPoolList->getNextMemoryPool();
tmpMemPool->clearNext();
mMemoryPoolProvider->releaseMemoryPool(tmpMemPool);
}
if (mUsingMemoryPool) {
mMemoryPoolProvider->releaseMemoryPool(mUsingMemoryPool);
}
mFreeMemoryPoolCount = 0;
}
void* CMemoryPoolAllocationManager::allocate(size_t size) {
void* memPtr = 0;
char* memBlock = 0;
if (size >= 8) {
memBlock = getMemoryBlock(size*sizeof(char),8);
} else if (size >= 4) {
memBlock = getMemoryBlock(size*sizeof(char),4);
} else if (size >= 2) {
memBlock = getMemoryBlock(size*sizeof(char),2);
} else {
memBlock = getMemoryBlock(size*sizeof(char));
}
memPtr = memBlock;
return memPtr;
}
CMemoryAllocationManager* CMemoryPoolAllocationManager::release(void* address) {
// not supported by this pool memory manager, use releaseAllMemory()
return this;
}
void* CMemoryPoolAllocationManager::allocateAligned(size_t size, int alignment) {
void* memPtr = 0;
char* memBlock = getMemoryBlock(size*sizeof(char),alignment);
memPtr = memBlock;
return memPtr;
}
char* CMemoryPoolAllocationManager::getMemoryBlock(cint64 memoryBlockSize) {
char* memBlock = 0;
bool allocated = false;
while (!allocated) {
if (!mUsingMemoryPool) {
if (!mFreeMemoryPoolList) {
mFreeMemoryPoolList = mMemoryPoolProvider->acquireMemoryPool(memoryBlockSize);
++mFreeMemoryPoolCount;
}
mUsingMemoryPool = mFreeMemoryPoolList;
mFreeMemoryPoolList = mFreeMemoryPoolList->getNextMemoryPool();
mUsingMemoryPool->clearNext();
--mFreeMemoryPoolCount;
++mStatMemToUsingCount;
}
if (mUsingMemoryPool) {
char* memBlockEnd = mUsingMemoryPool->getMemoryBlockEnd();
char* memBlockPointer = mUsingMemoryPool->getMemoryBlockPointer();
if (memBlockPointer+memoryBlockSize <= memBlockEnd) {
memBlock = memBlockPointer;
mUsingMemoryPool->setMemoryBlockPointer(memBlockPointer+memoryBlockSize);
allocated = true;
} else {
// move pool to used
CMemoryPool* tmpMemPool = mUsingMemoryPool;
mUsedMemoryPoolList = tmpMemPool->setNextMemoryPool(mUsedMemoryPoolList);
mUsingMemoryPool = nullptr;
}
}
}
return memBlock;
}
char* CMemoryPoolAllocationManager::getMemoryBlock(cint64 memoryBlockSize, cint64 alignment) {
char* memBlock = 0;
bool allocated = false;
while (!allocated) {
if (!mUsingMemoryPool) {
if (!mFreeMemoryPoolList) {
mFreeMemoryPoolList = mMemoryPoolProvider->acquireMemoryPool(memoryBlockSize+alignment);
++mFreeMemoryPoolCount;
}
mUsingMemoryPool = mFreeMemoryPoolList;
mFreeMemoryPoolList = mFreeMemoryPoolList->getNextMemoryPool();
mUsingMemoryPool->clearNext();
--mFreeMemoryPoolCount;
++mStatMemToUsingCount;
}
if (mUsingMemoryPool) {
char* memBlockEnd = mUsingMemoryPool->getMemoryBlockEnd();
char* memBlockPointer = mUsingMemoryPool->getMemoryBlockPointer();
cint64 maxBlockAlloc = (cint64)memBlockPointer+(cint64)memoryBlockSize+alignment;
if (maxBlockAlloc <= (cint64)memBlockEnd) {
// alignment is 2^N
cint64 alignmentMask = alignment-1;
memBlock = memBlockPointer;
if (alignmentMask & cint64(memBlock)) {
memBlock = (char*)((cint64(memBlock) & ~alignmentMask) + alignment);
}
mUsingMemoryPool->setMemoryBlockPointer(memBlock+memoryBlockSize);
allocated = true;
} else {
// move pool to used
CMemoryPool* tmpMemPool = mUsingMemoryPool;
mUsedMemoryPoolList = tmpMemPool->setNextMemoryPool(mUsedMemoryPoolList);
mUsingMemoryPool = nullptr;
}
}
}
return memBlock;
}
CMemoryTemporaryAllocationManager* CMemoryPoolAllocationManager::releaseAllMemory() {
// move all used memory pools to free list
CMemoryPool* tmpMemPool = nullptr;
while (mUsedMemoryPoolList) {
tmpMemPool = mUsedMemoryPoolList;
tmpMemPool->resetMemoryBlockPointer();
mUsedMemoryPoolList = mUsedMemoryPoolList->getNextMemoryPool();
mFreeMemoryPoolList = tmpMemPool->setNextMemoryPool(mFreeMemoryPoolList);
++mFreeMemoryPoolCount;
++mStatMemToFreeCount;
}
if (mUsingMemoryPool) {
mUsingMemoryPool->resetMemoryBlockPointer();
mFreeMemoryPoolList = mUsingMemoryPool->setNextMemoryPool(mFreeMemoryPoolList);
++mFreeMemoryPoolCount;
++mStatMemToFreeCount;
mUsingMemoryPool = nullptr;
}
return this;
}
CMemoryPool* CMemoryPoolAllocationManager::acqireTemporaryMemoryPool(size_t size) {
CMemoryPool* tmpMemoryPool = nullptr;
if (mFreeMemoryPoolList) {
if (mFreeMemoryPoolList->getMemoryBlockSize() >= size) {
tmpMemoryPool = mFreeMemoryPoolList;
mFreeMemoryPoolList = mFreeMemoryPoolList->getNextMemoryPool();
--mFreeMemoryPoolCount;
}
}
if (!tmpMemoryPool) {
tmpMemoryPool = mMemoryPoolProvider->acquireMemoryPool(size);
}
if (tmpMemoryPool) {
++mStatMemToUsingCount;
tmpMemoryPool->clearNext();
}
return tmpMemoryPool;
}
CMemoryTemporaryAllocationManager* CMemoryPoolAllocationManager::releaseTemporaryMemoryPool(CMemoryPool* memoryPool) {
memoryPool->resetMemoryBlockPointer();
memoryPool->setNextMemoryPool(mFreeMemoryPoolList);
mFreeMemoryPoolList = memoryPool;
++mFreeMemoryPoolCount;
++mStatMemToFreeCount;
return this;
}
cint64 CMemoryPoolAllocationManager::getOptimizedMoreAllocationSize(cint64 size) {
if (mUsingMemoryPool) {
cint64 availableSizeThisPool = mUsingMemoryPool->getMemoryBlockEnd() - mUsingMemoryPool->getMemoryBlockData();
if (availableSizeThisPool >= size) {
return qMax(availableSizeThisPool,size<<2);
} else if (mUsingMemoryPool->getMemoryBlockSize() >= size) {
return qMax(mUsingMemoryPool->getMemoryBlockSize(),size<<2);
}
} else if (mFreeMemoryPoolList) {
cint64 availableSizeThisPool = mFreeMemoryPoolList->getMemoryBlockEnd() - mFreeMemoryPoolList->getMemoryBlockData();
if (availableSizeThisPool >= size) {
return qMax(availableSizeThisPool,size<<2);
} else if (mUsingMemoryPool->getMemoryBlockSize() >= size) {
return qMax(mUsingMemoryPool->getMemoryBlockSize(),size<<2);
}
}
return size;
}
CMemoryTemporaryAllocationManager* CMemoryPoolAllocationManager::releaseMemoryPoolContainer(CMemoryPoolContainer* memoryPoolContainer) {
CMemoryPool* memoryPoolLinker = memoryPoolContainer->takeMemoryPools();
return releaseTemporaryMemoryPools(memoryPoolLinker);
}
cint64 CMemoryPoolAllocationManager::getFreeMemoryPoolCount() {
return mFreeMemoryPoolCount;
}
CMemoryTemporaryAllocationManager* CMemoryPoolAllocationManager::addUsedMemoryPools(CMemoryPool* memoryPools) {
mUsedMemoryPoolList = memoryPools->append(mUsedMemoryPoolList);
return this;
}
}; // end namespace Memory
}; // end namespace Utilities
}; // end namespace Konclude