/*
* 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