/*
* 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 "CMemoryPoolContainerAllocationManager.h"
namespace Konclude {
namespace Utilities {
namespace Memory {
CMemoryPoolContainerAllocationManager::CMemoryPoolContainerAllocationManager(CMemoryPoolContainer* memoryPoolContainer, CMemoryPoolProvider* memoryPoolProvider) {
mMemoryPoolContainer = memoryPoolContainer;
mMemoryPoolProvider = memoryPoolProvider;
mStatPoolAllocCount = 0;
mStatAllocPoolSize = 0;
}
CMemoryPoolContainerAllocationManager::~CMemoryPoolContainerAllocationManager() {
}
void* CMemoryPoolContainerAllocationManager::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* CMemoryPoolContainerAllocationManager::release(void* address) {
// not supported by this pool memory manager, stored all memory in memory pool container
return this;
}
void* CMemoryPoolContainerAllocationManager::allocateAligned(size_t size, int alignment) {
void* memPtr = 0;
char* memBlock = getMemoryBlock(size*sizeof(char),alignment);
memPtr = memBlock;
return memPtr;
}
char* CMemoryPoolContainerAllocationManager::getMemoryBlock(cint64 memoryBlockSize) {
#ifdef KONCLUDE_DIRECT_NEW_MEMORY_ALLOCATION
return new char[memoryBlockSize];
#endif // KONCLUDE_DIRECT_NEW_MEMORY_ALLOCATION
char* memBlock = 0;
bool allocated = false;
CMemoryPool* memoryPool = mMemoryPoolContainer->getMemoryPools();
while (!allocated) {
if (!memoryPool) {
memoryPool = mMemoryPoolProvider->acquireMemoryPool(memoryBlockSize);
++mStatPoolAllocCount;
if (memoryPool) {
mStatAllocPoolSize += memoryPool->getMemoryBlockSize();
mMemoryPoolContainer->appendMemoryPool(memoryPool);
}
}
if (memoryPool) {
char* memBlockEnd = memoryPool->getMemoryBlockEnd();
char* memBlockPointer = memoryPool->getMemoryBlockPointer();
if (memBlockPointer+memoryBlockSize < memBlockEnd) {
memBlock = memBlockPointer;
memoryPool->setMemoryBlockPointer(memBlockPointer+memoryBlockSize);
allocated = true;
} else {
memoryPool = nullptr;
}
}
}
return memBlock;
}
cint64 CMemoryPoolContainerAllocationManager::getOptimizedMoreAllocationSize(cint64 size) {
CMemoryPool* memoryPool = mMemoryPoolContainer->getMemoryPools();
if (memoryPool) {
cint64 availableSizeThisPool = memoryPool->getMemoryBlockEnd() - memoryPool->getMemoryBlockData();
if (availableSizeThisPool >= size) {
return qMax(availableSizeThisPool,size<<2);
} else if (memoryPool->getMemoryBlockSize() >= size) {
return qMax(memoryPool->getMemoryBlockSize(),size<<2);
}
}
return size;
}
char* CMemoryPoolContainerAllocationManager::getMemoryBlock(cint64 memoryBlockSize, cint64 alignment) {
#ifdef KONCLUDE_DIRECT_NEW_MEMORY_ALLOCATION
char* data = new char[memoryBlockSize + alignment];
cint64 alignmentMask = alignment - 1;
if (alignmentMask & cint64(data)) {
data = (char*)((cint64(data) & ~alignmentMask) + alignment);
}
return data;
#endif // KONCLUDE_DIRECT_NEW_MEMORY_ALLOCATION
char* memBlock = 0;
bool allocated = false;
CMemoryPool* memoryPool = mMemoryPoolContainer->getMemoryPools();
while (!allocated) {
if (!memoryPool) {
memoryPool = mMemoryPoolProvider->acquireMemoryPool(memoryBlockSize+alignment);
++mStatPoolAllocCount;
if (memoryPool) {
mStatAllocPoolSize += memoryPool->getMemoryBlockSize();
mMemoryPoolContainer->appendMemoryPool(memoryPool);
}
}
if (memoryPool) {
char* memBlockEnd = memoryPool->getMemoryBlockEnd();
char* memBlockPointer = memoryPool->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);
}
memoryPool->setMemoryBlockPointer(memBlock+memoryBlockSize);
allocated = true;
} else {
memoryPool = nullptr;
}
}
}
return memBlock;
}
void* CMemoryPoolContainerAllocationManager::allocateMemoryToContainer(size_t size, CMemoryPoolContainer* memoryPoolContainer, CMemoryPoolProvider* memoryPoolProvider) {
cint64 memoryBlockSize = size;
char* memBlock = 0;
bool allocated = false;
CMemoryPool* memoryPool = memoryPoolContainer->getMemoryPools();
while (!allocated) {
if (!memoryPool) {
memoryPool = memoryPoolProvider->acquireMemoryPool(memoryBlockSize);
memoryPoolContainer->appendMemoryPool(memoryPool);
}
if (memoryPool) {
char* memBlockEnd = memoryPool->getMemoryBlockEnd();
char* memBlockPointer = memoryPool->getMemoryBlockPointer();
if (memBlockPointer+memoryBlockSize < memBlockEnd) {
memBlock = memBlockPointer;
memoryPool->setMemoryBlockPointer(memBlockPointer+memoryBlockSize);
allocated = true;
} else {
memoryPool = nullptr;
}
}
}
return memBlock;
}
}; // end namespace Memory
}; // end namespace Utilities
}; // end namespace Konclude