/* * 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 . * */ #ifndef KONCLUDE_UTILITIES_CDYNAMICEXPANDINGMEMORYMANAGER_H #define KONCLUDE_UTILITIES_CDYNAMICEXPANDINGMEMORYMANAGER_H // Libraries includes #include // Namespace includes #include "CAllocationObject.h" #include "UtilitiesSettings.h" #include "CMemoryReleaser.h" #include "CMemoryManager.hpp" // Other includes // Logger includes #include "Logger/CLogger.h" using namespace Konclude::Logger; namespace Konclude { namespace Utilities { /*! * * \class CDynamicExpandingMemoryManager * \author Andreas Steigmiller * \version 0.1 * \brief TODO * */ template class CDynamicExpandingMemoryManager : public CMemoryManager { // public methods public: //! Constructor CDynamicExpandingMemoryManager(qreal expansionFactor = 10., qint64 beginExtensionSize = 8, qint64 maxExtensionSize = 2040, qint64 beginAllocationSize = 0); //! Destructor virtual ~CDynamicExpandingMemoryManager(); virtual T *allocate(); virtual void release(T *&mem); virtual void release(CAllocationObject *object); void clear(); // protected methods protected: // private methods private: void extendMemory(); // private variables private: qint64 totalElements; qint64 freeElements; qint64 nextMemVecIndex; qint64 releaseMemVecIndex; qint64 vecSize; qreal extendFac; qint64 minExtSize; qint64 maxExtSize; qint64 currExtSizeInt; qreal currExtSizeReal; QList memory; QList free; QList memoryPtr; QList freeMemPtr; T **releaseMemVec; T **nextMemVec; bool hasAllocationContextChecked; bool hasAllocationContext; }; template CDynamicExpandingMemoryManager::CDynamicExpandingMemoryManager(qreal expansionFactor, qint64 beginExtensionSize, qint64 maxExtensionSize, qint64 beginAllocationSize) { vecSize = maxExtensionSize; extendFac = expansionFactor; minExtSize = beginExtensionSize; maxExtSize = maxExtensionSize; currExtSizeInt = minExtSize; currExtSizeReal = minExtSize; releaseMemVec = 0; nextMemVec = 0; nextMemVecIndex = 0; releaseMemVecIndex = 0; freeElements = 0; totalElements = 0; hasAllocationContextChecked = false; hasAllocationContext = false; for (qint64 i = 0; i < beginAllocationSize; i += vecSize) { extendMemory(); } } template CDynamicExpandingMemoryManager::~CDynamicExpandingMemoryManager() { clear(); } template void CDynamicExpandingMemoryManager::clear() { releaseMemVec = 0; nextMemVec = 0; nextMemVecIndex = 0; releaseMemVecIndex = 0; freeElements = 0; totalElements = 0; foreach (T *mem, memory) { delete [] mem; } foreach (T **memPtr, memoryPtr) { delete [] memPtr; } memory.clear(); free.clear(); memoryPtr.clear(); freeMemPtr.clear(); } template void CDynamicExpandingMemoryManager::extendMemory() { T *newMem = new T[currExtSizeInt]; if (!hasAllocationContextChecked) { CAllocationObject *allCon = dynamic_cast(&newMem[0]); if (allCon == 0) { hasAllocationContext = false; } else { hasAllocationContext = true; } hasAllocationContextChecked = true; } freeElements += currExtSizeInt; totalElements += currExtSizeInt; memory.append(newMem); T **newMemPtr = new T *[vecSize]; memoryPtr.append(newMemPtr); for (int i = 0; i < currExtSizeInt; ++i) { newMemPtr[i] = &(newMem[i]); } for (int i = currExtSizeInt; i < vecSize; ++i) { newMemPtr[i] = 0; } free.append(newMemPtr); currExtSizeReal *= extendFac; if (currExtSizeReal > maxExtSize) { currExtSizeReal = maxExtSize; } currExtSizeInt = (qint64)currExtSizeReal; } template T *CDynamicExpandingMemoryManager::allocate() { T *memElement = 0; while (!memElement) { if (nextMemVec) { memElement = nextMemVec[nextMemVecIndex++]; if (nextMemVecIndex >= vecSize) { freeMemPtr.append(nextMemVec); nextMemVec = 0; } } if (memElement == 0) { if (free.isEmpty()) { extendMemory(); } nextMemVec = free.takeFirst(); nextMemVecIndex = 0; } } freeElements--; if (hasAllocationContext) { CAllocationObject *allCon = (CAllocationObject *)(memElement); allCon->setMemoryReleaser(this); } return memElement; } template void CDynamicExpandingMemoryManager::release(T *&mem) { if (releaseMemVec == 0) { if (!freeMemPtr.isEmpty()) { releaseMemVec = freeMemPtr.takeFirst(); } else { releaseMemVec = new T *[vecSize]; memoryPtr.append(releaseMemVec); } } freeElements++; releaseMemVec[releaseMemVecIndex++] = mem; mem = 0; if (releaseMemVecIndex >= vecSize) { releaseMemVecIndex = 0; if (releaseMemVec != 0) { free.append(releaseMemVec); releaseMemVec = 0; } } } template void CDynamicExpandingMemoryManager::release(CAllocationObject *object) { T *mem = (T*)object; release(mem); } }; // end namespace Utilities }; // end namespace Konclude #endif // KONCLUDE_UTILITIES_CDYNAMICEXPANDINGMEMORYMANAGER_H