/* * 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 "CReuseCompletionGraphCache.h" #include "CReuseCompletionGraphCacheWriter.h" namespace Konclude { namespace Reasoner { namespace Kernel { namespace Cache { CReuseCompletionGraphCache::CReuseCompletionGraphCache(QString threadIdentifierName, CWatchDog *watchDogThread) : CThread(threadIdentifierName,watchDogThread) { startThread(QThread::HighestPriority); mSlotLinker = nullptr; mReaderLinker = nullptr; CMemoryAllocationManager* memMan = mContext.getMemoryAllocationManager(); mEntyHash = CObjectParameterizingAllocator< CReuseCompletionGraphCompatibilityEntryHash,CContext* >::allocateAndConstructAndParameterize(memMan,&mContext); mEntyList = CObjectParameterizingAllocator< CCACHINGLIST,CContext* >::allocateAndConstructAndParameterize(memMan,&mContext); mEntryCount = 0; } CReuseCompletionGraphCache::~CReuseCompletionGraphCache() { } void CReuseCompletionGraphCache::createReaderSlotUpdate(CReuseCompletionGraphCacheContext* context) { CMemoryPoolProvider* memProv = context->getMemoryPoolAllocationManager(); CReuseCompletionGraphCacheSlotItem* slot = CObjectMemoryPoolAllocator::allocateAndConstructWithMemroyPool(memProv); CMemoryPoolContainerAllocationManager slotMemMan(slot,memProv); CMemoryAllocationManager* memMan = &slotMemMan; CContextBase tmpContext(memMan); CReuseCompletionGraphCompatibilityEntryHash* entyHash = CObjectParameterizingAllocator< CReuseCompletionGraphCompatibilityEntryHash,CContext* >::allocateAndConstructAndParameterize(memMan,&tmpContext); *entyHash = *mEntyHash; entyHash->detach(); slot->setEntryHash(entyHash); slot->setEntryCount(mEntryCount); if (mSlotLinker) { mSlotLinker->append(slot); } else { mSlotLinker = slot; } CReuseCompletionGraphCacheReader* readerLinkerIt = mReaderLinker; while (readerLinkerIt) { slot->incReader(); readerLinkerIt->updateSlot(slot); readerLinkerIt = readerLinkerIt->getNext(); } } void CReuseCompletionGraphCache::cleanUnusedSlots(CReuseCompletionGraphCacheContext* context) { CMemoryPoolAllocationManager* memMan = context->getMemoryPoolAllocationManager(); CReuseCompletionGraphCacheSlotItem* slotLinkerIt = mSlotLinker; CReuseCompletionGraphCacheSlotItem* lastSlotLinker = nullptr; while (slotLinkerIt) { CReuseCompletionGraphCacheSlotItem* tmpSlotLinker = nullptr; if (!slotLinkerIt->hasCacheReaders()) { tmpSlotLinker = slotLinkerIt; } CReuseCompletionGraphCacheSlotItem* nextSlotLinker = slotLinkerIt->getNext(); if (tmpSlotLinker) { if (!lastSlotLinker) { mSlotLinker = nextSlotLinker; } else { lastSlotLinker->setNext(nextSlotLinker); } CMemoryPool* memoryPools = tmpSlotLinker->getMemoryPools(); memMan->releaseTemporaryMemoryPools(memoryPools); } else { lastSlotLinker = slotLinkerIt; } slotLinkerIt = nextSlotLinker; } } CReuseCompletionGraphCacheReader* CReuseCompletionGraphCache::createCacheReader() { CReuseCompletionGraphCacheReader* reader = new CReuseCompletionGraphCacheReader(); mReaderSyncMutex.lock(); mReaderLinker = reader->append(mReaderLinker); mReaderSyncMutex.unlock(); return reader; } CReuseCompletionGraphCacheWriter* CReuseCompletionGraphCache::createCacheWriter() { CReuseCompletionGraphCacheWriter* writer = new CReuseCompletionGraphCacheWriter(this); return writer; } CReuseCompletionGraphCache* CReuseCompletionGraphCache::writeExpandCache(CReuseCompletionGraphCacheEntryWriteData* writeData, CMemoryPool* memoryPools) { postEvent(new CWriteCachedDataEvent(writeData,memoryPools)); return this; } void CReuseCompletionGraphCache::writeExpandCacheData(CReuseCompletionGraphCacheContext* context, CCACHINGLIST* cacheList, CCACHINGLIST* minimalCacheList, CSatisfiableCalculationJobInstantiation* jobInst) { CMemoryAllocationManager* memMan = context->getMemoryAllocationManager(); CReuseCompletionGraphCacheEntry* newEntry = CObjectParameterizingAllocator< CReuseCompletionGraphCacheEntry,CReuseCompletionGraphCacheContext* >::allocateAndConstructAndParameterize(memMan,context); newEntry->setJobInstantiation(jobInst); mEntyList->append(newEntry); newEntry->setEntryID(mEntryCount); for (CCACHINGLIST::const_iterator it = cacheList->constBegin(), itEnd = cacheList->constEnd(); it != itEnd; ++it) { const CCacheValue& cacheValue = *it; CReuseCompletionGraphCompatibilityEntryHashData& hashData = (*mEntyHash)[cacheValue]; CXLinker* linker = CObjectAllocator< CXLinker >::allocateAndConstruct(memMan); linker->initLinker(newEntry); hashData.addEntailedEntyLinker(linker); newEntry->addEntailedValue(cacheValue); } for (CCACHINGLIST::const_iterator it = minimalCacheList->constBegin(), itEnd = minimalCacheList->constEnd(); it != itEnd; ++it) { const CCacheValue& cacheValue = *it; newEntry->addMinimalValue(cacheValue); } ++mEntryCount; } bool CReuseCompletionGraphCache::processCustomsEvents(QEvent::Type type, CCustomEvent *event) { if (CThread::processCustomsEvents(type,event)) { return true; } if (type == CWriteCachedDataEvent::EVENTTYPE) { CWriteCachedDataEvent* wcde = (CWriteCachedDataEvent*)event; CMemoryPool* memoryPools = wcde->getMemoryPools(); CReuseCompletionGraphCacheEntryWriteData* dataLinkerIt = (CReuseCompletionGraphCacheEntryWriteData*)wcde->getWriteData(); while (dataLinkerIt) { if (dataLinkerIt->getCacheWriteDataType() == CReuseCompletionGraphCacheEntryWriteData::REUSECOMPLETIONGRAPHWRITEEXPANDDATATYPE) { CReuseCompletionGraphCacheEntryExpandWriteData* writeExpandData = (CReuseCompletionGraphCacheEntryExpandWriteData*)dataLinkerIt; CCACHINGLIST* cacheList = writeExpandData->getCacheValueList(); CCACHINGLIST* minimalCacheList = writeExpandData->getCacheValueList(); CSatisfiableCalculationJobInstantiation* jobInst = writeExpandData->getJobInstantiation(); writeExpandCacheData(&mContext,cacheList,minimalCacheList,jobInst); } dataLinkerIt = (CReuseCompletionGraphCacheEntryWriteData*)dataLinkerIt->getNext(); } createReaderSlotUpdate(&mContext); cleanUnusedSlots(&mContext); mContext.getMemoryPoolAllocationManager()->releaseTemporaryMemoryPools(memoryPools); } return false; } }; // end namespace Cache }; // end namespace Kernel }; // end namespace Reasoner }; // end namespace Konclude