/*
* 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 "CReuseCompletionGraphCacheReader.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Cache {
CReuseCompletionGraphCacheReader::CReuseCompletionGraphCacheReader() : CLinkerBase(this) {
mCurrentSlot = nullptr;
mFreeLinker = nullptr;
}
CReuseCompletionGraphCacheReader* CReuseCompletionGraphCacheReader::updateSlot(CReuseCompletionGraphCacheSlotItem* updatedSlot) {
CReuseCompletionGraphCacheSlotItem* prevSlot = mUpdatedSlot.fetchAndStoreOrdered(updatedSlot);
if (prevSlot != nullptr) {
prevSlot->decReader();
}
return this;
}
bool CReuseCompletionGraphCacheReader::hasUpdatedSlotItem() {
return mUpdatedSlot.fetchAndAddRelaxed(0) != nullptr;
}
bool CReuseCompletionGraphCacheReader::switchToUpdatedSlotItem() {
CReuseCompletionGraphCacheSlotItem* updatedSlot = mUpdatedSlot.fetchAndStoreOrdered(nullptr);
if (updatedSlot) {
CReuseCompletionGraphCacheSlotItem* prevSlot = mCurrentSlot;
mCurrentSlot = updatedSlot;
if (prevSlot != nullptr) {
prevSlot->decReader();
}
return true;
}
return false;
}
CXLinker* CReuseCompletionGraphCacheReader::getConceptTestLinker() {
CXLinker* linker = nullptr;
if (mFreeLinker) {
linker = mFreeLinker;
mFreeLinker = mFreeLinker->getNext();
} else {
linker = CObjectAllocator< CXLinker >::allocateAndConstruct(mContext.getMemoryAllocationManager());
}
linker->clearNext();
return linker;
}
CReuseCompletionGraphCacheReader* CReuseCompletionGraphCacheReader::releaseConceptTestLinker(CXLinker* linker) {
mFreeLinker = linker->append(mFreeLinker);
return this;
}
bool CReuseCompletionGraphCacheReader::addTestingConcepts(CSortedNegLinker* conLinker, bool negate, cint64 addingLevel, CCACHINGSET* testedConceptSet) {
bool oneAdded = false;
for (CSortedNegLinker* conLinkerIt = conLinker; conLinkerIt; conLinkerIt = conLinkerIt->getNext()) {
CConcept* concept = conLinkerIt->getData();
bool negated = conLinkerIt->isNegated();
oneAdded |= addTestingConcept(concept,negated^negate,addingLevel,testedConceptSet);
}
return oneAdded;
}
bool CReuseCompletionGraphCacheReader::addTestingConcept(CConcept* concept, bool negated, cint64 addingLevel, CCACHINGSET* testedConceptSet) {
if (!testedConceptSet->contains(concept)) {
testedConceptSet->insert(concept);
CXLinker* newLinker = getConceptTestLinker();
newLinker->initLinker(TConceptNegPair(concept,negated));
if (addingLevel < mTestConceptLinkerLevel) {
addingLevel = mTestConceptLinkerLevel;
}
mTestConceptLinkerVec[addingLevel] = newLinker->append(mTestConceptLinkerVec[addingLevel]);
++mTestConceptLinkerCount;
return true;
}
return false;
}
CReuseCompletionGraphCacheEntry* CReuseCompletionGraphCacheReader::getCacheEntry(CConcept* concept, bool* minimalCompletionGraph, bool* deterministicConnection) {
CReuseCompletionGraphCacheEntry* entry = nullptr;
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
if (mCurrentSlot) {
CReuseCompletionGraphCompatibilityEntryHash* entryHash = mCurrentSlot->getEntryHash();
cint64 entryCount = mCurrentSlot->getEntryCount();
if (entryCount > 0) {
if (mEntryVotingVec.size() < entryCount) {
mEntryVotingVec.resize(entryCount);
}
for (cint64 i = 0; i < entryCount; ++i) {
CCacheEntryVotingItem& item = mEntryVotingVec[i];
item.reset();
}
CCACHINGSET testedConceptSet(&mContext);
for (cint64 i = 0; i < mTestConceptLinkerVecSize; ++i) {
mTestConceptLinkerVec[i] = nullptr;
}
mTestConceptLinkerCount = 1;
mTestConceptLinkerLevel = 0;
CXLinker* testConceptLinker = getConceptTestLinker();
testConceptLinker->initLinker(TConceptNegPair(concept,false));
mTestConceptLinkerVec[0] = testConceptLinker;
testedConceptSet.insert(concept);
while (mTestConceptLinkerCount > 0) {
CXLinker* tmpTestConLinker = nullptr;
for (; mTestConceptLinkerLevel < mTestConceptLinkerVecSize; ++mTestConceptLinkerLevel) {
tmpTestConLinker = mTestConceptLinkerVec[mTestConceptLinkerLevel];
if (tmpTestConLinker) {
mTestConceptLinkerVec[mTestConceptLinkerLevel] = tmpTestConLinker->getNext();
tmpTestConLinker->clearNext();
break;
}
}
--mTestConceptLinkerCount;
CConcept* testCon = tmpTestConLinker->getData().first;
bool testConNeg = tmpTestConLinker->getData().second;
bool searchOperandConcepts = true;
if (!testConNeg && testCon->hasClassName()) {
// test whether concept is available in cache
CCacheValue cacheValue(testCon->getConceptTag(),(cint64)testCon,CCacheValue::CACHEVALTAGANDCONCEPT);
const CReuseCompletionGraphCompatibilityEntryHashData& data = entryHash->value(cacheValue);
CXLinker* entailedEntryLinker = data.getEntailedEntryLinker();
CXLinker* incompatibleEntryLinker = data.getIncompatibleEntryLinker();
if (entailedEntryLinker || incompatibleEntryLinker) {
for (CXLinker* entailedEntryLinkerIt = entailedEntryLinker; entailedEntryLinkerIt; entailedEntryLinkerIt = entailedEntryLinkerIt->getNext()) {
CReuseCompletionGraphCacheEntry* entry = entailedEntryLinkerIt->getData();
CCacheEntryVotingItem& item = mEntryVotingVec[entry->getEntryID()];
item.mEntry = entry;
item.mEntailedCount++;
item.mTmpReferenced = true;
item.mMinConnectionLevel = qMin(item.mMinConnectionLevel,mTestConceptLinkerLevel);
item.mMinimalFound |= entry->hasMinimalValue(cacheValue);
}
for (CXLinker* incompatibleEntryLinkerIt = incompatibleEntryLinker; incompatibleEntryLinkerIt; incompatibleEntryLinkerIt = incompatibleEntryLinkerIt->getNext()) {
CReuseCompletionGraphCacheEntry* entry = incompatibleEntryLinkerIt->getData();
CCacheEntryVotingItem& item = mEntryVotingVec[entry->getEntryID()];
item.mEntry = entry;
item.mIncompatibleCount++;
item.mTmpReferenced = true;
}
for (cint64 i = 0; i < entryCount; ++i) {
CCacheEntryVotingItem& item = mEntryVotingVec[i];
if (!item.mTmpReferenced) {
item.mMissingCount++;
} else {
item.mTmpReferenced = false;
}
}
searchOperandConcepts = false;
}
}
if (searchOperandConcepts) {
CRole* role = testCon->getRole();
if (role) {
addTestingConcepts(role->getDomainConceptList(),false,0,&testedConceptSet);
addTestingConcepts(role->getRangeConceptList(),false,2,&testedConceptSet);
}
cint64 opCode = testCon->getOperatorCode();
CSortedNegLinker* opLinker = testCon->getOperandList();
if (!testConNeg && (opCode == CCIMPLAQAND || opCode == CCBRANCHAQAND || opCode == CCAQAND || opCode == CCEQ || opCode == CCAND || opCode == CCSUB || opCode == CCIMPLTRIG) || testConNeg && (opCode == CCOR)) {
addTestingConcepts(opLinker,testConNeg,0,&testedConceptSet);
} else if (!testConNeg && (opCode == CCOR) || testConNeg && (opCode == CCEQ || opCode == CCAND)) {
addTestingConcepts(opLinker,testConNeg,3,&testedConceptSet);
} else if (!testConNeg && (opCode == CCSOME || opCode == CCAQSOME) || testConNeg && (opCode == CCALL)) {
addTestingConcepts(opLinker,testConNeg,1,&testedConceptSet);
} else if (!testConNeg && (opCode == CCATLEAST) || testConNeg && (opCode == CCATMOST)) {
cint64 cardinality = testCon->getParameter() + 1*testConNeg;
if (cardinality >= 1) {
addTestingConcepts(opLinker,testConNeg,1,&testedConceptSet);
}
} else if (opCode == CCAQALL || opCode == CCIMPLALL || opCode == CCBRANCHALL) {
addTestingConcepts(opLinker,false,2,&testedConceptSet);
} else if (opCode == CCATMOST || opCode == CCATLEAST) {
addTestingConcepts(opLinker,false,3,&testedConceptSet);
} else if (opCode == CCIMPL) {
addTestingConcept(opLinker->getData(),opLinker->isNegated(),0,&testedConceptSet);
} else if (opCode == CCAQCHOOCE) {
for (CSortedNegLinker* opLinkerIt = opLinker; opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
if (opLinkerIt->isNegated() == testConNeg) {
addTestingConcept(opLinkerIt->getData(),false,0,&testedConceptSet);
}
}
}
}
releaseConceptTestLinker(tmpTestConLinker);
}
cint64 minMissingCount = 0;
CCacheEntryVotingItem* bestEntryItem = nullptr;
for (cint64 i = 0; i < entryCount; ++i) {
CCacheEntryVotingItem& item = mEntryVotingVec[i];
if (item.mEntailedCount >= 1 && item.mIncompatibleCount <= 0 && (bestEntryItem == nullptr || minMissingCount < item.mMissingCount)) {
minMissingCount = item.mMissingCount;
bestEntryItem = &item;
}
}
if (bestEntryItem) {
entry = bestEntryItem->mEntry;
if (deterministicConnection) {
*deterministicConnection = bestEntryItem->mMinConnectionLevel <= 1;
}
if (minimalCompletionGraph) {
*minimalCompletionGraph = bestEntryItem->mMinimalFound;
}
}
}
}
return entry;
}
}; // end namespace Cache
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude