int
removeSubsumed(Array<BinaryTree_AVL<Clause> > &clarray, unsigned int curdepth)
{
// list of tautologies to remove
List<Clause> clausesToRemove;
// check if these tests should be run
if (!subsumptiontest)
return(OK);
// check if any clause at the current depth is subsumed
// by a clause at a lower level.
//
BinaryTree_AVL_Iterator_InOrder<Clause> cdIter(clarray[curdepth]);
for ( ; !cdIter.done(); cdIter++)
{
// check if the current clause is subsumed
for (int idepth = 0; idepth < curdepth; idepth++)
{
// get previous depth clauses
BinaryTree_AVL_Iterator_InOrder<Clause>
idIter(clarray[idepth]);
for ( ; !idIter.done(); idIter++)
{
// check if a clause is a subset of
// another. comparison is done by
// comparing equivalent sets.
//
int status =
removedSubsumed(idIter(),
cdIter(), clausesToRemove);
if (status != OK)
return(status);
}
}
}
// remove any clauses
ListIterator<Clause> cltrIter(clausesToRemove);
for ( ; !cltrIter.done(); cltrIter++)
{
Clause clause(cltrIter());
int status = clarray[curdepth].remove(clause);
if (status != OK && status != NOMATCH)
{
ERROR("remove failed.", errno);
return(NOTOK);
}
}
// all done
return(OK);
}
// resolve clauses at a given depth
int
resolveDepth(Array<OrderedSet<Clause> > &clausesArray,
int &clausesAdded, unsigned int currentDepth)
{
// resolve the clauses at the current depth
// with clauses at previous depths
//
OrderedSetIterator<Clause> cdIter(clausesArray[currentDepth]);
for ( ; !cdIter.done(); cdIter++)
{
// scan the clauses in the equivalence set
ListIterator<Clause> cdclIter(cdIter.data());
for ( ; !cdclIter.done(); cdclIter++)
{
// scan the clauses at each depth
for (int idepth = 0; idepth <= currentDepth; idepth++)
{
// scan each equivalent set.
OrderedSetIterator<Clause>
idIter(clausesArray[idepth]);
for ( ; !idIter.done(); idIter++)
{
// scan the clauses in the
// equivalence set
ListIterator<Clause>
idclIter(idIter.data());
for ( ; !idclIter.done(); idclIter++)
{
// try to resolve the clauses
int status =
resolveClauses(
clausesArray,
cdclIter(),
idclIter(),
clausesAdded,
currentDepth);
// check for success, etc.
switch (status)
{
case OK:
case NOMATCH:
case CONTINUE:
break;
default:
return(status);
}
}
}
}
}
}
// all done
return(OK);
}
int
removeSubsumed(Array<OrderedSet<Clause> > &clarray, unsigned int curdepth)
{
// list of tautologies to remove
List<Clause> clausesToRemove;
// check if any clause at the current depth is subsumed
// by a clause at a lower level.
//
OrderedSetIterator<Clause> cdIter(clarray[curdepth]);
for ( ; !cdIter.done(); cdIter++)
{
// check if the current clause is subsumed
for (int idepth = 0; idepth <= curdepth; idepth++)
{
// get previous depth clauses
OrderedSetIterator<Clause> idIter(clarray[idepth]);
for ( ; !idIter.done(); idIter++)
{
// check if a clause is a subset of
// another. comparison is done
// comparing equivalent sets.
//
if (subset(idIter.key(), cdIter.key()) != OK)
continue;
// check each set for subsumed clauses
int status =
removedSubsumed(idIter.data(),
cdIter.data(), clausesToRemove);
if (status != OK)
return(status);
}
}
}
// remove any clauses
ListIterator<Clause> cltrIter(clausesToRemove);
for ( ; !cltrIter.done(); cltrIter++)
{
Clause clause(cltrIter());
if (clarray[curdepth].remove(clause) != OK)
return(NOTOK);
}
// all done
return(OK);
}
unsigned int WINAPI TaskSynch::SynchThreadProc(void *pContext)
{
TaskSynch *pSynch = reinterpret_cast<TaskSynch *>(pContext);
WaitForSingleObject(pSynch->m_synchMap.m_synchEvent, INFINITE);
ResetEvent(pSynch->m_synchMap.m_synchEvent);
while(pSynch->m_synchMap.GetCount())
{
SynchData *pSynchData = pSynch->m_synchMap.Get(0);
if(pSynchData)
{
Group *pGroup = pSynch->m_pDataManager->GetGroupManagerInstance()->GetGroup(pSynchData->m_sbGroup);
if(pGroup)
{
int count = 0;
unsigned __int64 *pIDs = pGroup->GetTaskIDs(&count);
//TODO: build sets then use diffSet to get the missing items.. synch the existing items
//and request the missing items
SortedSet<unsigned __int64> localIDs;
localIDs.addAll(pIDs, count);
SortedSet<unsigned __int64> foreignIDs;
delete [] pIDs;
foreignIDs.addAll(pSynchData->m_pIDs, pSynchData->m_taskCount);
CSet<unsigned __int64, 32> remainingIDs = localIDs.diff(foreignIDs);
IterWrapper<Task> iter(pGroup->IterateTasks());
while(iter.Next())
{
pSynch->SynchTaskTreeSeg(iter.Get(), pSynchData->m_ipSet[0]);
}
IterWrapper<unsigned __int64> idIter(remainingIDs.Iterate());
int len = 0;
char * pMsg = NULL;
while(idIter.Next())
{
pMsg = MakeReqTask(*idIter.Get(), &len, true);
pSynch->m_pNetwork->Send(pMsg, len, pSynchData->m_ipSet[0]);
}
}
}
pSynch->m_synchMap.RemoveItem(0);
}
pSynch->m_threadID = 0;
return 0;
}
