private void doRiaNode(
InternalWorkingMemory wm,
LeftInputAdapterNode liaNode,
PathMemory pmem,
TupleSets<LeftTuple> srcTuples,
BetaNode betaNode,
LeftTupleSinkNode sink,
SegmentMemory[] smems,
int smemIndex,
Memory nodeMem,
BetaMemory bm,
LinkedList<StackEntry> stack,
RuleExecutor executor) {
RiaPathMemory pathMem = bm.getRiaRuleMemory();
SegmentMemory[] subnetworkSmems = pathMem.getSegmentMemories();
SegmentMemory subSmem = null;
for (int i = 0; subSmem == null; i++) {
// segment positions outside of the subnetwork, in the parent chain, are null
// so we must iterate to find the first non null segment memory
subSmem = subnetworkSmems[i];
}
// Resume the node after the riaNode segment has been processed and the right input memory
// populated
StackEntry stackEntry =
new StackEntry(
liaNode,
betaNode,
bm.getNodePosMaskBit(),
sink,
pmem,
nodeMem,
smems,
smemIndex,
srcTuples,
false,
false);
stack.add(stackEntry);
if (log.isTraceEnabled()) {
int offset = getOffset(betaNode);
log.trace(
"{} RiaQueue {} {}", indent(offset), betaNode.toString(), srcTuples.toStringSizes());
}
TupleSets<LeftTuple> subLts = subSmem.getStagedLeftTuples().takeAll();
// node is first in the segment, so bit is 1
innerEval(
liaNode,
pathMem,
subSmem.getRootNode(),
1,
subSmem.getNodeMemories().getFirst(),
subnetworkSmems,
subSmem.getPos(),
subLts,
wm,
stack,
true,
executor);
}
public void setupJoinNode() {
buildContext = createContext();
joinNode =
(JoinNode)
BetaNodeBuilder.create(NodeTypeEnums.JoinNode, buildContext)
.setLeftType(A.class)
.setBinding("object", "$object")
.setRightType(B.class)
.setConstraint("object", "!=", "$object")
.build();
sinkNode = new JoinNode();
sinkNode.setId(1);
sinkNode.setConstraints(new EmptyBetaConstraints());
joinNode.addTupleSink(sinkNode);
wm =
((StatefulKnowledgeSessionImpl)
buildContext.getKnowledgeBase().newStatefulKnowledgeSession());
bm = (BetaMemory) wm.getNodeMemory(joinNode);
bm0 = (BetaMemory) wm.getNodeMemory(sinkNode);
smem = new SegmentMemory(joinNode);
bm.setSegmentMemory(smem);
smem0 = new SegmentMemory(sinkNode);
bm0.setSegmentMemory(smem0);
smem.add(smem0);
}
public void updateSink(
final ObjectSink sink,
final PropagationContext context,
final InternalWorkingMemory workingMemory) {
BetaNode betaNode = (BetaNode) this.sink.getSinks()[0];
Memory betaMemory = workingMemory.getNodeMemory(betaNode);
BetaMemory bm;
if (betaNode.getType() == NodeTypeEnums.AccumulateNode) {
bm = ((AccumulateMemory) betaMemory).getBetaMemory();
} else {
bm = (BetaMemory) betaMemory;
}
// for RIA nodes, we need to store the ID of the created handles
bm.getRightTupleMemory().iterator();
if (bm.getRightTupleMemory().size() > 0) {
final org.drools.core.util.Iterator it = bm.getRightTupleMemory().iterator();
for (RightTuple entry = (RightTuple) it.next();
entry != null;
entry = (RightTuple) it.next()) {
LeftTuple leftTuple = (LeftTuple) entry.getFactHandle().getObject();
InternalFactHandle handle = (InternalFactHandle) leftTuple.getObject();
sink.assertObject(handle, context, workingMemory);
}
}
}
private static ProtobufMessages.NodeMemory writeRIANodeMemory(
final int nodeId,
final MarshallerWriteContext context,
final BaseNode node,
final NodeMemories memories,
final Memory memory) {
RightInputAdapterNode riaNode = (RightInputAdapterNode) node;
ObjectSink[] sinks = riaNode.getSinkPropagator().getSinks();
BetaNode betaNode = (BetaNode) sinks[0];
Memory betaMemory = memories.peekNodeMemory(betaNode.getId());
if (betaMemory == null) {
return null;
}
BetaMemory bm;
if (betaNode.getType() == NodeTypeEnums.AccumulateNode) {
bm = ((AccumulateMemory) betaMemory).getBetaMemory();
} else {
bm = (BetaMemory) betaMemory;
}
// for RIA nodes, we need to store the ID of the created handles
bm.getRightTupleMemory().iterator();
if (bm.getRightTupleMemory().size() > 0) {
ProtobufMessages.NodeMemory.RIANodeMemory.Builder _ria =
ProtobufMessages.NodeMemory.RIANodeMemory.newBuilder();
final org.drools.core.util.Iterator it = bm.getRightTupleMemory().iterator();
// iterates over all propagated handles and assert them to the new sink
for (RightTuple entry = (RightTuple) it.next();
entry != null;
entry = (RightTuple) it.next()) {
LeftTuple leftTuple = (LeftTuple) entry.getFactHandle().getObject();
InternalFactHandle handle = (InternalFactHandle) leftTuple.getObject();
FactHandle _handle =
ProtobufMessages.FactHandle.newBuilder()
.setId(handle.getId())
.setRecency(handle.getRecency())
.build();
_ria.addContext(
ProtobufMessages.NodeMemory.RIANodeMemory.RIAContext.newBuilder()
.setTuple(PersisterHelper.createTuple(leftTuple))
.setResultHandle(_handle)
.build());
}
return ProtobufMessages.NodeMemory.newBuilder()
.setNodeId(nodeId)
.setNodeType(ProtobufMessages.NodeMemory.NodeType.RIA)
.setRia(_ria.build())
.build();
}
return null;
}
public static void unlinkNotNodeOnRightInsert(
NotNode notNode, BetaMemory bm, InternalWorkingMemory wm) {
if (bm.getSegmentMemory().isSegmentLinked()
&& !notNode.isRightInputIsRiaNode()
&& notNode.isEmptyBetaConstraints()) {
// this must be processed here, rather than initial insert, as we need to link the blocker
// @TODO this could be more efficient, as it means the entire StagedLeftTuples for all
// previous nodes where evaluated, needlessly.
bm.unlinkNode(wm);
}
}
@Test
public void testPopulatedSharedLiaNode() throws Exception {
KnowledgeBase kbase1 = buildKnowledgeBase("r1", " A() B(1;) C() D() E()\n");
InternalWorkingMemory wm = ((InternalWorkingMemory) kbase1.newStatefulKnowledgeSession());
List list = new ArrayList();
wm.setGlobal("list", list);
wm.insert(new A(1));
wm.insert(new A(2));
wm.insert(new A(3));
wm.insert(new B(1));
wm.insert(new B(2));
wm.insert(new C(1));
wm.insert(new D(1));
wm.insert(new E(1));
wm.fireAllRules();
assertEquals(3, list.size());
kbase1.addKnowledgePackages(buildKnowledgePackage("r2", " a : A() B(2;) C() D() E()\n"));
ObjectTypeNode aotn = getObjectTypeNode(kbase1, A.class);
LeftInputAdapterNode liaNode = (LeftInputAdapterNode) aotn.getSinkPropagator().getSinks()[0];
JoinNode bNode1 = (JoinNode) liaNode.getSinkPropagator().getFirstLeftTupleSink();
JoinNode bNode2 = (JoinNode) liaNode.getSinkPropagator().getLastLeftTupleSink();
BetaMemory bm = (BetaMemory) wm.getNodeMemory(bNode2);
SegmentMemory sm = bm.getSegmentMemory();
assertNotNull(sm.getStagedLeftTuples().getInsertFirst());
assertNotNull(sm.getStagedLeftTuples().getInsertFirst().getStagedNext());
assertNotNull(sm.getStagedLeftTuples().getInsertFirst().getStagedNext().getStagedNext());
assertNull(
sm.getStagedLeftTuples().getInsertFirst().getStagedNext().getStagedNext().getStagedNext());
wm.fireAllRules();
assertNull(sm.getStagedLeftTuples().getInsertFirst());
assertEquals(6, list.size());
assertEquals("r1", ((Match) list.get(0)).getRule().getName());
assertEquals("r1", ((Match) list.get(1)).getRule().getName());
assertEquals("r1", ((Match) list.get(2)).getRule().getName());
assertEquals("r2", ((Match) list.get(3)).getRule().getName());
assertEquals("r2", ((Match) list.get(4)).getRule().getName());
assertEquals("r2", ((Match) list.get(5)).getRule().getName());
List results = new ArrayList();
results.add(((A) ((Match) list.get(3)).getDeclarationValue("a")).getObject());
results.add(((A) ((Match) list.get(4)).getDeclarationValue("a")).getObject());
results.add(((A) ((Match) list.get(5)).getDeclarationValue("a")).getObject());
assertTrue(results.containsAll(asList(1, 2, 3)));
}
private static boolean processStreamTupleEntry(
TupleEntryQueue tupleQueue, TupleEntry tupleEntry) {
boolean isNonNormalizedDelete = false;
if (log.isTraceEnabled()) {
log.trace(
"Stream removed entry {} {} size {}",
System.identityHashCode(tupleQueue),
tupleEntry,
tupleQueue.size());
}
if (tupleEntry.getLeftTuple() != null) {
SegmentMemory sm = tupleEntry.getNodeMemory().getSegmentMemory();
LeftTupleSets tuples = sm.getStagedLeftTuples();
tupleEntry.getLeftTuple().setPropagationContext(tupleEntry.getPropagationContext());
switch (tupleEntry.getPropagationType()) {
case PropagationContext.INSERTION:
case PropagationContext.RULE_ADDITION:
tuples.addInsert(tupleEntry.getLeftTuple());
break;
case PropagationContext.MODIFICATION:
tuples.addUpdate(tupleEntry.getLeftTuple());
break;
case PropagationContext.DELETION:
case PropagationContext.EXPIRATION:
case PropagationContext.RULE_REMOVAL:
isNonNormalizedDelete = tupleEntry.getLeftTuple().getStagedType() == LeftTuple.NONE;
tuples.addDelete(tupleEntry.getLeftTuple());
break;
}
} else {
BetaMemory bm = (BetaMemory) tupleEntry.getNodeMemory();
tupleEntry.getRightTuple().setPropagationContext(tupleEntry.getPropagationContext());
switch (tupleEntry.getPropagationType()) {
case PropagationContext.INSERTION:
case PropagationContext.RULE_ADDITION:
bm.getStagedRightTuples().addInsert(tupleEntry.getRightTuple());
break;
case PropagationContext.MODIFICATION:
bm.getStagedRightTuples().addUpdate(tupleEntry.getRightTuple());
break;
case PropagationContext.DELETION:
case PropagationContext.EXPIRATION:
case PropagationContext.RULE_REMOVAL:
isNonNormalizedDelete = tupleEntry.getRightTuple().getStagedType() == LeftTuple.NONE;
bm.getStagedRightTuples().addDelete(tupleEntry.getRightTuple());
break;
}
}
return isNonNormalizedDelete;
}
public void doLeftDeletes(
BetaMemory bm,
LeftTupleSets srcLeftTuples,
LeftTupleSets trgLeftTuples,
LeftTupleSets stagedLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
for (LeftTuple leftTuple = srcLeftTuples.getDeleteFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
RightTuple blocker = leftTuple.getBlocker();
if (blocker == null) {
if (leftTuple.getMemory() != null) {
// it may have been staged and never actually added
ltm.remove(leftTuple);
}
LeftTuple childLeftTuple = leftTuple.getFirstChild();
if (childLeftTuple != null) { // NotNode only has one child
childLeftTuple.setPropagationContext(leftTuple.getPropagationContext());
RuleNetworkEvaluator.deleteLeftChild(
childLeftTuple,
trgLeftTuples,
stagedLeftTuples); // no need to update pctx, as no right available, and pctx will
// exist on a parent LeftTuple anyway
}
} else {
blocker.removeBlocked(leftTuple);
}
leftTuple.clearStaged();
leftTuple = next;
}
}
public static void doUpdatesReorderRightMemory(
BetaMemory bm, TupleSets<RightTuple> srcRightTuples) {
TupleMemory rtm = bm.getRightTupleMemory();
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
if (rightTuple.getMemory() != null) {
rightTuple.setTempRightTupleMemory(rightTuple.getMemory());
rtm.remove(rightTuple);
}
rightTuple = next;
}
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
if (rightTuple.getTempRightTupleMemory() != null) {
rtm.add(rightTuple);
for (LeftTuple childLeftTuple = rightTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getRightParentNext();
childLeftTuple.reAddLeft();
childLeftTuple = childNext;
}
}
rightTuple = next;
}
}
public static void doUpdatesExistentialReorderLeftMemory(
BetaMemory bm, TupleSets<LeftTuple> srcLeftTuples) {
TupleMemory ltm = bm.getLeftTupleMemory();
// sides must first be re-ordered, to ensure iteration integrity
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
if (leftTuple.getMemory() != null) {
ltm.remove(leftTuple);
}
leftTuple = next;
}
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
RightTuple blocker = leftTuple.getBlocker();
if (blocker == null) {
ltm.add(leftTuple);
for (LeftTuple childLeftTuple = leftTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getHandleNext();
childLeftTuple.reAddRight();
childLeftTuple = childNext;
}
} else if (blocker.getStagedType() != LeftTuple.NONE) {
// it's blocker is also being updated, so remove to force it to start from the beginning
blocker.removeBlocked(leftTuple);
}
leftTuple = next;
}
}
public static void dpUpdatesExistentialReorderLeftMemory(
BetaMemory bm, LeftTupleSets srcLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
// sides must first be re-ordered, to ensure iteration integrity
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
if (leftTuple.getMemory() != null) {
ltm.remove(leftTuple);
}
leftTuple = next;
}
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
if (leftTuple.getBlocker() == null) {
ltm.add(leftTuple);
for (LeftTuple childLeftTuple = leftTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getLeftParentNext();
childLeftTuple.reAddRight();
childLeftTuple = childNext;
}
}
leftTuple = next;
}
}
public void doLeftInserts(
NotNode notNode,
LeftTupleSink sink,
BetaMemory bm,
InternalWorkingMemory wm,
LeftTupleSets srcLeftTuples,
LeftTupleSets trgLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
RightTupleMemory rtm = bm.getRightTupleMemory();
ContextEntry[] contextEntry = bm.getContext();
BetaConstraints constraints = notNode.getRawConstraints();
for (LeftTuple leftTuple = srcLeftTuples.getInsertFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
FastIterator it = notNode.getRightIterator(rtm);
boolean useLeftMemory = RuleNetworkEvaluator.useLeftMemory(notNode, leftTuple);
constraints.updateFromTuple(contextEntry, wm, leftTuple);
// This method will also remove rightTuples that are from subnetwork where no leftmemory use
// used
RuleNetworkEvaluator.findLeftTupleBlocker(
notNode, rtm, contextEntry, constraints, leftTuple, it, useLeftMemory);
if (leftTuple.getBlocker() == null) {
// tuple is not blocked, so add to memory so other fact handles can attempt to match
if (useLeftMemory) {
ltm.add(leftTuple);
}
trgLeftTuples.addInsert(
sink.createLeftTuple(
leftTuple,
sink,
leftTuple.getPropagationContext(),
useLeftMemory)); // use leftTuple pctx here, as no right input caused the trigger
// anway
}
leftTuple.clearStaged();
leftTuple = next;
}
constraints.resetTuple(contextEntry);
}
public Boolean call() throws Exception {
EntryPoint ep = ksession.getEntryPoint("EP" + index);
InternalWorkingMemory wm = ((NamedEntryPoint) ep).getInternalWorkingMemory();
ObjectTypeNode otn =
((NamedEntryPoint) ep)
.getEntryPointNode()
.getObjectTypeNodes()
.values()
.iterator()
.next();
AlphaNode alpha = (AlphaNode) otn.getSinkPropagator().getSinks()[0];
BetaNode beta = (BetaNode) alpha.getSinkPropagator().getSinks()[0];
BetaMemory memory = (BetaMemory) wm.getNodeMemory(beta);
memory.getSegmentMemory();
for (int i = 0; i < 100; i++) {
Thread.sleep(RANDOM.nextInt(100));
if (fh == null) {
fh = ep.insert("" + index);
} else {
if (RANDOM.nextInt(100) < 70) {
ep.delete(fh);
fh = null;
} else {
ep.update(fh, "" + index);
}
}
}
if (index == deleteIndex) {
if (fh != null) {
ep.delete(fh);
fh = null;
}
} else if (fh == null) {
fh = ep.insert("" + index);
}
return true;
}
@Override
protected void doVisit(
NetworkNode node, Stack<NetworkNode> nodeStack, StatefulKnowledgeSessionInfo info) {
RightInputAdapterNode an = (RightInputAdapterNode) node;
DefaultNodeInfo ni = (DefaultNodeInfo) info.getNodeInfo(node);
BetaNode betaNode = (BetaNode) an.getSinkPropagator().getSinks()[0];
Memory childMemory = info.getSession().getNodeMemory(betaNode);
BetaMemory bm;
if (betaNode.getType() == NodeTypeEnums.AccumulateNode) {
bm = ((AccumulateMemory) childMemory).getBetaMemory();
} else {
bm = (BetaMemory) childMemory;
}
ni.setMemoryEnabled(true);
ni.setTupleMemorySize(bm.getRightTupleMemory().size());
ni.setCreatedFactHandles(bm.getRightTupleMemory().size());
}
public void doNode(
NotNode notNode,
LeftTupleSink sink,
BetaMemory bm,
InternalWorkingMemory wm,
LeftTupleSets srcLeftTuples,
LeftTupleSets trgLeftTuples,
LeftTupleSets stagedLeftTuples) {
RightTupleSets srcRightTuples = bm.getStagedRightTuples().takeAll();
if (srcLeftTuples.getDeleteFirst() != null) {
// left deletes must come before right deletes. Otherwise right deletes could
// stage an insertion, that is later deleted in the rightDelete, causing potential problems
doLeftDeletes(bm, srcLeftTuples, trgLeftTuples, stagedLeftTuples);
}
if (srcLeftTuples.getUpdateFirst() != null) {
// must happen before right inserts, so it can find left tuples to block.
RuleNetworkEvaluator.doUpdatesExistentialReorderLeftMemory(bm, srcLeftTuples);
}
if (srcRightTuples.getUpdateFirst() != null) {
RuleNetworkEvaluator.doUpdatesExistentialReorderRightMemory(
bm, notNode, srcRightTuples); // this also preserves the next rightTuple
}
if (srcRightTuples.getInsertFirst() != null) {
// must come before right updates and inserts, as they might cause insert propagation, while
// this causes delete propagations, resulting in staging clash.
doRightInserts(notNode, bm, wm, srcRightTuples, trgLeftTuples, stagedLeftTuples);
}
if (srcRightTuples.getUpdateFirst() != null) {
// must come after rightInserts and before rightDeletes, to avoid staging clash
doRightUpdates(notNode, sink, bm, wm, srcRightTuples, trgLeftTuples, stagedLeftTuples);
}
if (srcRightTuples.getDeleteFirst() != null) {
// must come after rightUpdates, to avoid staging clash
doRightDeletes(notNode, sink, bm, wm, srcRightTuples, trgLeftTuples);
}
if (srcLeftTuples.getUpdateFirst() != null) {
doLeftUpdates(notNode, sink, bm, wm, srcLeftTuples, trgLeftTuples, stagedLeftTuples);
}
if (srcLeftTuples.getInsertFirst() != null) {
doLeftInserts(notNode, sink, bm, wm, srcLeftTuples, trgLeftTuples);
}
srcRightTuples.resetAll();
srcLeftTuples.resetAll();
}
public void doLeftDeletes(
FromMemory fm,
TupleSets<LeftTuple> srcLeftTuples,
TupleSets<LeftTuple> trgLeftTuples,
TupleSets<LeftTuple> stagedLeftTuples) {
BetaMemory bm = fm.getBetaMemory();
TupleMemory ltm = bm.getLeftTupleMemory();
for (LeftTuple leftTuple = srcLeftTuples.getDeleteFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
ltm.remove(leftTuple);
Map<Object, RightTuple> matches = (Map<Object, RightTuple>) leftTuple.getContextObject();
if (leftTuple.getFirstChild() != null) {
LeftTuple childLeftTuple = leftTuple.getFirstChild();
while (childLeftTuple != null) {
childLeftTuple.setPropagationContext(leftTuple.getPropagationContext());
LeftTuple nextChild = childLeftTuple.getLeftParentNext();
RuleNetworkEvaluator.unlinkAndDeleteChildLeftTuple(
childLeftTuple, trgLeftTuples, stagedLeftTuples);
childLeftTuple = nextChild;
}
}
// if matches == null, the deletion might be happening before the fact was even propagated.
// See BZ-1019473 for details.
if (matches != null) {
// @TODO (mdp) is this really necessary? won't the entire FH and RightTuple chaines just et
// GC'd?
unlinkCreatedHandles(leftTuple);
}
leftTuple.clearStaged();
leftTuple = next;
}
}
public void removeMemory(InternalWorkingMemory workingMemory) {
BetaNode betaNode = (BetaNode) this.sink.getSinks()[0];
Memory betaMemory = workingMemory.getNodeMemory(betaNode);
BetaMemory bm;
if (betaNode.getType() == NodeTypeEnums.AccumulateNode) {
bm = ((AccumulateMemory) betaMemory).getBetaMemory();
} else {
bm = (BetaMemory) betaMemory;
}
if (bm.getRightTupleMemory().size() > 0) {
final Iterator it = bm.getRightTupleMemory().iterator();
for (RightTuple entry = (RightTuple) it.next();
entry != null;
entry = (RightTuple) it.next()) {
LeftTuple leftTuple = (LeftTuple) entry.getFactHandle().getObject();
leftTuple.unlinkFromLeftParent();
leftTuple.unlinkFromRightParent();
}
}
workingMemory.clearNodeMemory(this);
}
public static void doUpdatesReorderLeftMemory(BetaMemory bm, TupleSets<LeftTuple> srcLeftTuples) {
TupleMemory ltm = bm.getLeftTupleMemory();
// sides must first be re-ordered, to ensure iteration integrity
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
ltm.remove(leftTuple);
leftTuple = next;
}
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
ltm.add(leftTuple);
for (LeftTuple childLeftTuple = leftTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getHandleNext();
childLeftTuple.reAddRight();
childLeftTuple = childNext;
}
leftTuple = next;
}
}
private void switchOnDoBetaNode(
NetworkNode node,
TupleSets<LeftTuple> trgTuples,
InternalWorkingMemory wm,
TupleSets<LeftTuple> srcTuples,
TupleSets<LeftTuple> stagedLeftTuples,
LeftTupleSinkNode sink,
BetaMemory bm,
AccumulateMemory am) {
if (log.isTraceEnabled()) {
int offset = getOffset(node);
log.trace("{} rightTuples {}", indent(offset), bm.getStagedRightTuples().toStringSizes());
}
switch (node.getType()) {
case NodeTypeEnums.JoinNode:
{
pJoinNode.doNode((JoinNode) node, sink, bm, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
case NodeTypeEnums.NotNode:
{
pNotNode.doNode((NotNode) node, sink, bm, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
case NodeTypeEnums.ExistsNode:
{
pExistsNode.doNode(
(ExistsNode) node, sink, bm, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
case NodeTypeEnums.AccumulateNode:
{
pAccNode.doNode(
(AccumulateNode) node, sink, am, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
}
}
public void doLeftUpdates(
NotNode notNode,
LeftTupleSink sink,
BetaMemory bm,
InternalWorkingMemory wm,
LeftTupleSets srcLeftTuples,
LeftTupleSets trgLeftTuples,
LeftTupleSets stagedLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
RightTupleMemory rtm = bm.getRightTupleMemory();
ContextEntry[] contextEntry = bm.getContext();
BetaConstraints constraints = notNode.getRawConstraints();
boolean leftUpdateOptimizationAllowed = notNode.isLeftUpdateOptimizationAllowed();
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
FastIterator rightIt = notNode.getRightIterator(rtm);
RightTuple firstRightTuple = notNode.getFirstRightTuple(leftTuple, rtm, null, rightIt);
// If in memory, remove it, because we'll need to add it anyway if it's not blocked, to ensure
// iteration order
RightTuple blocker = leftTuple.getBlocker();
if (blocker == null) {
if (leftTuple.getMemory()
!= null) { // memory can be null, if blocker was deleted in same do loop
ltm.remove(leftTuple);
}
} else {
// check if we changed bucket
if (rtm.isIndexed() && !rightIt.isFullIterator()) {
// if newRightTuple is null, we assume there was a bucket change and that bucket is empty
if (firstRightTuple == null || firstRightTuple.getMemory() != blocker.getMemory()) {
blocker.removeBlocked(leftTuple);
blocker = null;
}
}
}
constraints.updateFromTuple(contextEntry, wm, leftTuple);
if (!leftUpdateOptimizationAllowed && blocker != null) {
blocker.removeBlocked(leftTuple);
blocker = null;
}
// if we where not blocked before (or changed buckets), or the previous blocker no longer
// blocks, then find the next blocker
if (blocker == null
|| !constraints.isAllowedCachedLeft(contextEntry, blocker.getFactHandle())) {
if (blocker != null) {
// remove previous blocker if it exists, as we know it doesn't block any more
blocker.removeBlocked(leftTuple);
}
// find first blocker, because it's a modify, we need to start from the beginning again
for (RightTuple newBlocker = firstRightTuple;
newBlocker != null;
newBlocker = (RightTuple) rightIt.next(newBlocker)) {
if (constraints.isAllowedCachedLeft(contextEntry, newBlocker.getFactHandle())) {
leftTuple.setBlocker(newBlocker);
newBlocker.addBlocked(leftTuple);
break;
}
}
LeftTuple childLeftTuple = leftTuple.getFirstChild();
if (leftTuple.getBlocker() != null) {
// blocked
if (childLeftTuple != null) {
// blocked, with previous children, so must have not been previously blocked, so retract
// no need to remove, as we removed at the start
// to be matched against, as it's now blocked
childLeftTuple.setPropagationContext(
leftTuple
.getBlocker()
.getPropagationContext()); // we have the righttuple, so use it for the pctx
RuleNetworkEvaluator.deleteLeftChild(childLeftTuple, trgLeftTuples, stagedLeftTuples);
} // else: it's blocked now and no children so blocked before, thus do nothing
} else if (childLeftTuple == null) {
// not blocked, with no children, must have been previously blocked so assert
ltm.add(leftTuple); // add to memory so other fact handles can attempt to match
trgLeftTuples.addInsert(
sink.createLeftTuple(
leftTuple,
sink,
leftTuple.getPropagationContext(),
true)); // use leftTuple for the pctx here, as the right one is not available
// this won't cause a problem, as the trigger tuple (to the left) will be more recent
// anwyay
} else {
updateChildLeftTuple(childLeftTuple, stagedLeftTuples, trgLeftTuples);
// not blocked, with children, so wasn't previous blocked and still isn't so modify
ltm.add(leftTuple); // add to memory so other fact handles can attempt to match
childLeftTuple.reAddLeft();
}
}
leftTuple.clearStaged();
leftTuple = next;
}
constraints.resetTuple(contextEntry);
}
@Test
public void testPopulatedRuleWithEvals() throws Exception {
KnowledgeBase kbase1 = buildKnowledgeBase("r1", " a:A() B() eval(1==1) eval(1==1) C(1;) \n");
InternalWorkingMemory wm = ((InternalWorkingMemory) kbase1.newStatefulKnowledgeSession());
List list = new ArrayList();
wm.setGlobal("list", list);
wm.insert(new A(1));
wm.insert(new A(2));
wm.insert(new A(3));
wm.insert(new B(1));
wm.insert(new C(1));
wm.insert(new C(2));
wm.fireAllRules();
assertEquals(3, list.size());
kbase1.addKnowledgePackages(
buildKnowledgePackage("r2", " a:A() B() eval(1==1) eval(1==1) C(2;) \n"));
ObjectTypeNode aotn = getObjectTypeNode(kbase1, A.class);
LeftInputAdapterNode liaNode = (LeftInputAdapterNode) aotn.getSinkPropagator().getSinks()[0];
JoinNode bNode = (JoinNode) liaNode.getSinkPropagator().getFirstLeftTupleSink();
EvalConditionNode e1 = (EvalConditionNode) bNode.getSinkPropagator().getFirstLeftTupleSink();
EvalConditionNode e2 = (EvalConditionNode) e1.getSinkPropagator().getFirstLeftTupleSink();
JoinNode c1Node = (JoinNode) e2.getSinkPropagator().getFirstLeftTupleSink();
JoinNode c2Node = (JoinNode) e2.getSinkPropagator().getLastLeftTupleSink();
LiaNodeMemory lm = (LiaNodeMemory) wm.getNodeMemory(liaNode);
SegmentMemory sm = lm.getSegmentMemory();
BetaMemory c1Mem = (BetaMemory) wm.getNodeMemory(c1Node);
assertSame(sm.getFirst(), c1Mem.getSegmentMemory());
assertEquals(3, c1Mem.getLeftTupleMemory().size());
assertEquals(1, c1Mem.getRightTupleMemory().size());
BetaMemory c2Mem = (BetaMemory) wm.getNodeMemory(c2Node);
SegmentMemory c2Smem = sm.getFirst().getNext();
assertSame(c2Smem, c2Mem.getSegmentMemory());
assertEquals(0, c2Mem.getLeftTupleMemory().size());
assertEquals(0, c2Mem.getRightTupleMemory().size());
assertNotNull(c2Smem.getStagedLeftTuples().getInsertFirst());
assertNotNull(c2Smem.getStagedLeftTuples().getInsertFirst().getStagedNext());
assertNotNull(c2Smem.getStagedLeftTuples().getInsertFirst().getStagedNext().getStagedNext());
assertNull(
c2Smem
.getStagedLeftTuples()
.getInsertFirst()
.getStagedNext()
.getStagedNext()
.getStagedNext());
wm.fireAllRules();
assertEquals(3, c2Mem.getLeftTupleMemory().size());
assertEquals(1, c2Mem.getRightTupleMemory().size());
assertNull(c2Smem.getStagedLeftTuples().getInsertFirst());
assertEquals(6, list.size());
assertEquals("r1", ((Match) list.get(0)).getRule().getName());
assertEquals("r1", ((Match) list.get(1)).getRule().getName());
assertEquals("r1", ((Match) list.get(2)).getRule().getName());
assertEquals("r2", ((Match) list.get(3)).getRule().getName());
assertEquals(3, ((A) ((Match) list.get(3)).getDeclarationValue("a")).getObject());
assertEquals("r2", ((Match) list.get(4)).getRule().getName());
assertEquals(2, ((A) ((Match) list.get(4)).getDeclarationValue("a")).getObject());
assertEquals("r2", ((Match) list.get(5)).getRule().getName());
assertEquals(1, ((A) ((Match) list.get(5)).getDeclarationValue("a")).getObject());
}
public static void doUpdatesExistentialReorderRightMemory(
BetaMemory bm, BetaNode betaNode, TupleSets<RightTuple> srcRightTuples) {
TupleMemory rtm = bm.getRightTupleMemory();
boolean resumeFromCurrent =
!(betaNode.isIndexedUnificationJoin() || rtm.getIndexType().isComparison());
// remove all the staged rightTuples from the memory before to readd them all
// this is to avoid split bucket when an updated rightTuple hasn't been moved yet
// and so it is the first entry in the wrong bucket
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
if (rightTuple.getMemory() != null) {
rightTuple.setTempRightTupleMemory(rightTuple.getMemory());
if (resumeFromCurrent) {
if (rightTuple.getBlocked() != null) {
// look for a non-staged right tuple first forward ...
RightTuple tempRightTuple = (RightTuple) rightTuple.getNext();
while (tempRightTuple != null && tempRightTuple.getStagedType() != LeftTuple.NONE) {
// next cannot be an updated or deleted rightTuple
tempRightTuple = (RightTuple) tempRightTuple.getNext();
}
// ... and if cannot find one try backward
if (tempRightTuple == null) {
tempRightTuple = (RightTuple) rightTuple.getPrevious();
while (tempRightTuple != null && tempRightTuple.getStagedType() != LeftTuple.NONE) {
// next cannot be an updated or deleted rightTuple
tempRightTuple = (RightTuple) tempRightTuple.getPrevious();
}
}
rightTuple.setTempNextRightTuple(tempRightTuple);
}
}
rightTuple.setTempBlocked(rightTuple.getBlocked());
rightTuple.setBlocked(null);
rtm.remove(rightTuple);
}
rightTuple = next;
}
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
if (rightTuple.getTempRightTupleMemory() != null) {
rtm.add(rightTuple);
if (resumeFromCurrent) {
RightTuple tempRightTuple = rightTuple.getTempNextRightTuple();
if (rightTuple.getBlocked() != null
&& tempRightTuple == null
&& rightTuple.getMemory() == rightTuple.getTempRightTupleMemory()) {
// the next RightTuple was null, but current RightTuple was added back into the same
// bucket, so reset as root blocker to re-match can be attempted
rightTuple.setTempNextRightTuple(rightTuple);
}
}
for (LeftTuple childLeftTuple = rightTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getRightParentNext();
childLeftTuple.reAddLeft();
childLeftTuple = childNext;
}
}
rightTuple = next;
}
}
public void doLeftInserts(
FromNode fromNode,
FromMemory fm,
LeftTupleSink sink,
InternalWorkingMemory wm,
TupleSets<LeftTuple> srcLeftTuples,
TupleSets<LeftTuple> trgLeftTuples) {
BetaMemory bm = fm.getBetaMemory();
ContextEntry[] context = bm.getContext();
BetaConstraints betaConstraints = fromNode.getBetaConstraints();
AlphaNodeFieldConstraint[] alphaConstraints = fromNode.getAlphaConstraints();
DataProvider dataProvider = fromNode.getDataProvider();
Class<?> resultClass = fromNode.getResultClass();
for (LeftTuple leftTuple = srcLeftTuples.getInsertFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
PropagationContext propagationContext = leftTuple.getPropagationContext();
Map<Object, RightTuple> matches = null;
boolean useLeftMemory = RuleNetworkEvaluator.useLeftMemory(fromNode, leftTuple);
if (useLeftMemory) {
fm.getBetaMemory().getLeftTupleMemory().add(leftTuple);
matches = new LinkedHashMap<Object, RightTuple>();
leftTuple.setContextObject(matches);
}
betaConstraints.updateFromTuple(context, wm, leftTuple);
for (final java.util.Iterator<?> it =
dataProvider.getResults(leftTuple, wm, propagationContext, fm.providerContext);
it.hasNext(); ) {
final Object object = it.next();
if ((object == null) || !resultClass.isAssignableFrom(object.getClass())) {
continue; // skip anything if it not assignable
}
RightTuple rightTuple =
fromNode.createRightTuple(leftTuple, propagationContext, wm, object);
checkConstraintsAndPropagate(
sink,
leftTuple,
rightTuple,
alphaConstraints,
betaConstraints,
propagationContext,
wm,
fm,
context,
useLeftMemory,
trgLeftTuples,
null);
if (useLeftMemory) {
fromNode.addToCreatedHandlesMap(matches, rightTuple);
}
}
leftTuple.clearStaged();
leftTuple = next;
}
betaConstraints.resetTuple(context);
}
public void doLeftUpdates(
FromNode fromNode,
FromMemory fm,
LeftTupleSink sink,
InternalWorkingMemory wm,
TupleSets<LeftTuple> srcLeftTuples,
TupleSets<LeftTuple> trgLeftTuples,
TupleSets<LeftTuple> stagedLeftTuples) {
BetaMemory bm = fm.getBetaMemory();
ContextEntry[] context = bm.getContext();
BetaConstraints betaConstraints = fromNode.getBetaConstraints();
AlphaNodeFieldConstraint[] alphaConstraints = fromNode.getAlphaConstraints();
DataProvider dataProvider = fromNode.getDataProvider();
Class<?> resultClass = fromNode.getResultClass();
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
PropagationContext propagationContext = leftTuple.getPropagationContext();
final Map<Object, RightTuple> previousMatches =
(Map<Object, RightTuple>) leftTuple.getContextObject();
final Map<Object, RightTuple> newMatches = new HashMap<Object, RightTuple>();
leftTuple.setContextObject(newMatches);
betaConstraints.updateFromTuple(context, wm, leftTuple);
FastIterator rightIt = LinkedList.fastIterator;
for (final java.util.Iterator<?> it =
dataProvider.getResults(leftTuple, wm, propagationContext, fm.providerContext);
it.hasNext(); ) {
final Object object = it.next();
if ((object == null) || !resultClass.isAssignableFrom(object.getClass())) {
continue; // skip anything if it not assignable
}
RightTuple rightTuple = previousMatches.remove(object);
if (rightTuple == null) {
// new match, propagate assert
rightTuple = fromNode.createRightTuple(leftTuple, propagationContext, wm, object);
} else {
// previous match, so reevaluate and propagate modify
if (rightIt.next(rightTuple) != null) {
// handle the odd case where more than one object has the same hashcode/equals value
previousMatches.put(object, (RightTuple) rightIt.next(rightTuple));
rightTuple.setNext(null);
}
}
checkConstraintsAndPropagate(
sink,
leftTuple,
rightTuple,
alphaConstraints,
betaConstraints,
propagationContext,
wm,
fm,
context,
true,
trgLeftTuples,
null);
fromNode.addToCreatedHandlesMap(newMatches, rightTuple);
}
for (RightTuple rightTuple : previousMatches.values()) {
for (RightTuple current = rightTuple;
current != null;
current = (RightTuple) rightIt.next(current)) {
deleteChildLeftTuple(
propagationContext, trgLeftTuples, stagedLeftTuples, current.getFirstChild());
}
}
leftTuple.clearStaged();
leftTuple = next;
}
betaConstraints.resetTuple(context);
}
public void eval2(
LeftInputAdapterNode liaNode,
PathMemory rmem,
NetworkNode node,
Memory nodeMem,
SegmentMemory[] smems,
int smemIndex,
LeftTupleSets trgTuples,
InternalWorkingMemory wm,
LinkedList<StackEntry> stack,
Set<String> visitedRules,
boolean processRian,
RuleExecutor executor) {
LeftTupleSets srcTuples;
SegmentMemory smem = smems[smemIndex];
while (true) {
srcTuples = trgTuples; // previous target, is now the source
if (log.isTraceEnabled()) {
int offset = getOffset(node);
log.trace(
"{} {} {} {}", indent(offset), ++cycle, node.toString(), srcTuples.toStringSizes());
}
if (NodeTypeEnums.isTerminalNode(node)) {
TerminalNode rtn = (TerminalNode) node;
if (node.getType() == NodeTypeEnums.QueryTerminalNode) {
pQtNode.doNode((QueryTerminalNode) rtn, wm, srcTuples, stack);
} else {
pRtNode.doNode(rtn, wm, srcTuples, executor);
}
return;
} else if (NodeTypeEnums.RightInputAdaterNode == node.getType()) {
doRiaNode2(wm, srcTuples, (RightInputAdapterNode) node, stack);
return;
}
LeftTupleSets stagedLeftTuples;
if (node == smem.getTipNode() && smem.getFirst() != null) {
// we are about to process the segment tip, allow it to merge insert/update/delete clashes
// Can happen if the next segments have not yet been initialized
stagedLeftTuples = smem.getFirst().getStagedLeftTuples();
} else {
stagedLeftTuples = null;
}
LeftTupleSinkNode sink = ((LeftTupleSource) node).getSinkPropagator().getFirstLeftTupleSink();
trgTuples = new LeftTupleSets();
if (NodeTypeEnums.isBetaNode(node)) {
BetaNode betaNode = (BetaNode) node;
BetaMemory bm = null;
AccumulateMemory am = null;
if (NodeTypeEnums.AccumulateNode == node.getType()) {
am = (AccumulateMemory) nodeMem;
bm = am.getBetaMemory();
} else {
bm = (BetaMemory) nodeMem;
}
if (processRian && betaNode.isRightInputIsRiaNode()) {
// if the subnetwork is nested in this segment, it will create srcTuples containing
// peer LeftTuples, suitable for the node in the main path.
doRiaNode(
wm,
liaNode,
rmem,
srcTuples,
betaNode,
sink,
smems,
smemIndex,
nodeMem,
bm,
stack,
visitedRules,
executor);
return; // return here is doRiaNode queues the evaluation on the stack, which is necessary
// to handled nested query nodes
}
if (!bm.getDequeu().isEmpty()) {
// If there are no staged RightTuples, then process the Dequeue, popping entries, until
// another insert/expiration clash
RightTupleSets rightTuples = bm.getStagedRightTuples();
if (rightTuples.isEmpty()) {
// nothing staged, so now process the Dequeu
Deque<RightTuple> que = bm.getDequeu();
while (!que.isEmpty()) {
RightTuple rightTuple = que.peekFirst();
if (rightTuple.getPropagationContext().getType() == PropagationContext.EXPIRATION
&&
// Cannot pop an expired fact, if the insert/update has not yet been evaluated.
rightTuple.getStagedType() != LeftTuple.NONE) {
break;
}
switch (rightTuple.getPropagationContext().getType()) {
case PropagationContext.INSERTION:
case PropagationContext.RULE_ADDITION:
rightTuples.addInsert(rightTuple);
break;
case PropagationContext.MODIFICATION:
rightTuples.addUpdate(rightTuple);
break;
case PropagationContext.DELETION:
case PropagationContext.EXPIRATION:
case PropagationContext.RULE_REMOVAL:
rightTuples.addDelete(rightTuple);
break;
}
que.removeFirst();
}
}
if (!bm.getDequeu().isEmpty()) {
// The DeQue is not empty, add StackEntry for reprocessing.
StackEntry stackEntry =
new StackEntry(
liaNode,
node,
sink,
rmem,
nodeMem,
smems,
smemIndex,
trgTuples,
visitedRules,
false);
stack.add(stackEntry);
}
}
switch (node.getType()) {
case NodeTypeEnums.JoinNode:
{
pJoinNode.doNode(
(JoinNode) node, sink, bm, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
case NodeTypeEnums.NotNode:
{
pNotNode.doNode((NotNode) node, sink, bm, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
case NodeTypeEnums.ExistsNode:
{
pExistsNode.doNode(
(ExistsNode) node, sink, bm, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
case NodeTypeEnums.AccumulateNode:
{
pAccNode.doNode(
(AccumulateNode) node, sink, am, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
}
} else {
switch (node.getType()) {
case NodeTypeEnums.EvalConditionNode:
{
pEvalNode.doNode(
(EvalConditionNode) node,
(EvalMemory) nodeMem,
sink,
wm,
srcTuples,
trgTuples,
stagedLeftTuples);
break;
}
case NodeTypeEnums.FromNode:
{
pFromNode.doNode(
(FromNode) node,
(FromMemory) nodeMem,
sink,
wm,
srcTuples,
trgTuples,
stagedLeftTuples);
break;
}
case NodeTypeEnums.QueryElementNode:
{
QueryElementNodeMemory qmem = (QueryElementNodeMemory) nodeMem;
if (srcTuples.isEmpty() && qmem.getResultLeftTuples().isEmpty()) {
// no point in evaluating query element, and setting up stack, if there is nothing
// to process
break;
}
QueryElementNode qnode = (QueryElementNode) node;
if (visitedRules == Collections.<String>emptySet()) {
visitedRules = new HashSet<String>();
}
visitedRules.add(qnode.getQueryElement().getQueryName());
// result tuples can happen when reactivity occurs inside of the query, prior to
// evaluation
// we will need special behaviour to add the results again, when this query result
// resumes
trgTuples.addAll(qmem.getResultLeftTuples());
if (!srcTuples.isEmpty()) {
// only process the Query Node if there are src tuples
StackEntry stackEntry =
new StackEntry(
liaNode,
node,
sink,
rmem,
nodeMem,
smems,
smemIndex,
trgTuples,
visitedRules,
true);
stack.add(stackEntry);
pQueryNode.doNode(
qnode, (QueryElementNodeMemory) nodeMem, stackEntry, sink, wm, srcTuples);
SegmentMemory qsmem = ((QueryElementNodeMemory) nodeMem).getQuerySegmentMemory();
List<PathMemory> qrmems = qsmem.getPathMemories();
// Build the evaluation information for each 'or' branch
// Exception fo the last, place each entry on the stack, the last one evaluate now.
for (int i = qrmems.size() - 1; i >= 0; i--) {
PathMemory qrmem = qrmems.get(i);
rmem = qrmem;
smems = qrmem.getSegmentMemories();
smemIndex = 0;
smem = smems[smemIndex]; // 0
liaNode = (LeftInputAdapterNode) smem.getRootNode();
if (liaNode == smem.getTipNode()) {
// segment only has liaNode in it
// nothing is staged in the liaNode, so skip to next segment
smem = smems[++smemIndex]; // 1
node = smem.getRootNode();
nodeMem = smem.getNodeMemories().getFirst();
} else {
// lia is in shared segment, so point to next node
node = liaNode.getSinkPropagator().getFirstLeftTupleSink();
nodeMem =
smem.getNodeMemories().getFirst().getNext(); // skip the liaNode memory
}
trgTuples = smem.getStagedLeftTuples();
if (i != 0 && !trgTuples.isEmpty()) {
// All entries except the last should be placed on the stack for evaluation
// later.
stackEntry =
new StackEntry(
liaNode,
node,
null,
rmem,
nodeMem,
smems,
smemIndex,
trgTuples,
visitedRules,
false);
if (log.isTraceEnabled()) {
int offset = getOffset(stackEntry.getNode());
log.trace(
"{} ORQueue branch={} {} {}",
indent(offset),
i,
stackEntry.getNode().toString(),
trgTuples.toStringSizes());
}
stack.add(stackEntry);
}
}
processRian = true; // make sure it's reset, so ria nodes are processed
continue;
}
break;
}
case NodeTypeEnums.ConditionalBranchNode:
{
pBranchNode.doNode(
(ConditionalBranchNode) node,
(ConditionalBranchMemory) nodeMem,
sink,
wm,
srcTuples,
trgTuples,
stagedLeftTuples,
executor);
break;
}
}
}
if (node != smem.getTipNode()) {
// get next node and node memory in the segment
node = sink;
nodeMem = nodeMem.getNext();
} else {
// Reached end of segment, start on new segment.
SegmentPropagator.propagate(smem, trgTuples, wm);
smem = smems[++smemIndex];
trgTuples = smem.getStagedLeftTuples();
if (log.isTraceEnabled()) {
log.trace("Segment {}", smemIndex);
}
node = (LeftTupleSink) smem.getRootNode();
nodeMem = smem.getNodeMemories().getFirst();
}
processRian = true; // make sure it's reset, so ria nodes are processed
}
}
private void doRiaNode(
InternalWorkingMemory wm,
LeftInputAdapterNode liaNode,
PathMemory rmem,
LeftTupleSets srcTuples,
BetaNode betaNode,
LeftTupleSinkNode sink,
SegmentMemory[] smems,
int smemIndex,
Memory nodeMem,
BetaMemory bm,
LinkedList<StackEntry> stack,
Set<String> visitedRules,
RuleExecutor executor) {
RiaPathMemory pathMem = bm.getRiaRuleMemory();
SegmentMemory[] subnetworkSmems = pathMem.getSegmentMemories();
SegmentMemory subSmem = null;
for (int i = 0; subSmem == null; i++) {
// segment positions outside of the subnetwork, in the parent chain, are null
// so we must iterate to find the first non null segment memory
subSmem = subnetworkSmems[i];
}
// if (betaNode.getLeftTupleSource().getSinkPropagator().size() == 2) {
// // sub network is not part of share split, so need to handle propagation
// // this ensures the first LeftTuple is actually the subnetwork node
// // and the main outer network now receives the peer, notice the swap at the end
// "srcTuples == peerTuples"
// LeftTupleSets peerTuples = new LeftTupleSets();
// SegmentPropagator.processPeers(srcTuples, peerTuples, betaNode);
// // Make sure subnetwork Segment has tuples to process
// LeftTupleSets subnetworkStaged = subSmem.getStagedLeftTuples();
// subnetworkStaged.addAll(srcTuples);
//
// srcTuples.resetAll();
//
// srcTuples = peerTuples;
// }
// Resume the node after the riaNode segment has been processed and the right input memory
// populated
StackEntry stackEntry =
new StackEntry(
liaNode,
betaNode,
sink,
rmem,
nodeMem,
smems,
smemIndex,
srcTuples,
visitedRules,
false);
stack.add(stackEntry);
if (log.isTraceEnabled()) {
int offset = getOffset(betaNode);
log.trace(
"{} RiaQueue {} {}", indent(offset), betaNode.toString(), srcTuples.toStringSizes());
}
// RightInputAdapterNode riaNode = ( RightInputAdapterNode ) betaNode.getRightInput();
// RiaNodeMemory riaNodeMemory = (RiaNodeMemory) wm.getNodeMemory((MemoryFactory)
// betaNode.getRightInput());
// LeftTupleSets riaStagedTuples =
eval2(
liaNode,
pathMem,
(LeftTupleSink) subSmem.getRootNode(),
subSmem.getNodeMemories().getFirst(),
subnetworkSmems,
subSmem.getPos(),
subSmem.getStagedLeftTuples(),
wm,
stack,
visitedRules,
true,
executor);
}
public void doRightDeletes(
NotNode notNode,
LeftTupleSink sink,
BetaMemory bm,
InternalWorkingMemory wm,
RightTupleSets srcRightTuples,
LeftTupleSets trgLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
RightTupleMemory rtm = bm.getRightTupleMemory();
ContextEntry[] contextEntry = bm.getContext();
BetaConstraints constraints = notNode.getRawConstraints();
for (RightTuple rightTuple = srcRightTuples.getDeleteFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
FastIterator it = notNode.getRightIterator(rtm);
// assign now, so we can remove from memory before doing any possible propagations
boolean useComparisonIndex = rtm.getIndexType().isComparison();
RightTuple rootBlocker = useComparisonIndex ? null : (RightTuple) it.next(rightTuple);
if (rightTuple.getMemory() != null) {
// it may have been staged and never actually added
rtm.remove(rightTuple);
}
if (rightTuple.getBlocked() != null) {
for (LeftTuple leftTuple = rightTuple.getBlocked(); leftTuple != null; ) {
LeftTuple temp = leftTuple.getBlockedNext();
leftTuple.clearBlocker();
if (leftTuple.getStagedType() == LeftTuple.UPDATE) {
// ignore, as it will get processed via left iteration. Children cannot be processed
// twice
leftTuple = temp;
continue;
}
constraints.updateFromTuple(contextEntry, wm, leftTuple);
if (useComparisonIndex) {
rootBlocker = rtm.getFirst(leftTuple, null, it);
}
// we know that older tuples have been checked so continue next
for (RightTuple newBlocker = rootBlocker;
newBlocker != null;
newBlocker = (RightTuple) it.next(newBlocker)) {
if (constraints.isAllowedCachedLeft(contextEntry, newBlocker.getFactHandle())) {
leftTuple.setBlocker(newBlocker);
newBlocker.addBlocked(leftTuple);
break;
}
}
if (leftTuple.getBlocker() == null) {
// was previous blocked and not in memory, so add
ltm.add(leftTuple);
trgLeftTuples.addInsert(
sink.createLeftTuple(leftTuple, sink, rightTuple.getPropagationContext(), true));
}
leftTuple = temp;
}
}
rightTuple.nullBlocked();
rightTuple.clearStaged();
rightTuple = next;
}
constraints.resetTuple(contextEntry);
}
private void doRiaNode2(
InternalWorkingMemory wm, TupleSets<LeftTuple> srcTuples, RightInputAdapterNode riaNode) {
ObjectSink[] sinks = riaNode.getSinkPropagator().getSinks();
BetaNode betaNode = (BetaNode) sinks[0];
BetaMemory bm;
Memory nodeMem = wm.getNodeMemory(betaNode);
if (NodeTypeEnums.AccumulateNode == betaNode.getType()) {
bm = ((AccumulateMemory) nodeMem).getBetaMemory();
} else {
bm = (BetaMemory) nodeMem;
}
// Build up iteration array for other sinks
BetaNode[] bns = null;
BetaMemory[] bms = null;
int length = sinks.length;
if (length > 1) {
bns = new BetaNode[sinks.length - 1];
bms = new BetaMemory[sinks.length - 1];
for (int i = 1; i < length; i++) {
bns[i - 1] = (BetaNode) sinks[i];
Memory nodeMem2 = wm.getNodeMemory(bns[i - 1]);
if (NodeTypeEnums.AccumulateNode == betaNode.getType()) {
bms[i - 1] = ((AccumulateMemory) nodeMem2).getBetaMemory();
} else {
bms[i - 1] = (BetaMemory) nodeMem2;
}
}
}
length--; // subtract one, as first is not in the array;
for (LeftTuple leftTuple = srcTuples.getInsertFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
PropagationContext pctx = leftTuple.getPropagationContext();
InternalFactHandle handle = riaNode.createFactHandle(leftTuple, pctx, wm);
RightTuple rightTuple = new RightTupleImpl(handle, betaNode);
leftTuple.setContextObject(handle);
rightTuple.setPropagationContext(pctx);
if (bm.getStagedRightTuples().isEmpty()) {
bm.setNodeDirtyWithoutNotify();
}
bm.getStagedRightTuples().addInsert(rightTuple);
if (bns != null) {
// Add peered RightTuples, they are attached to FH - unlink LeftTuples that has a peer ref
for (int i = 0; i < length; i++) {
rightTuple = new RightTupleImpl(handle, bns[i]);
rightTuple.setPropagationContext(pctx);
if (bms[i].getStagedRightTuples().isEmpty()) {
bms[i].setNodeDirtyWithoutNotify();
}
bms[i].getStagedRightTuples().addInsert(rightTuple);
}
}
leftTuple.clearStaged();
leftTuple = next;
}
for (LeftTuple leftTuple = srcTuples.getDeleteFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
InternalFactHandle handle = (InternalFactHandle) leftTuple.getContextObject();
RightTuple rightTuple = handle.getFirstRightTuple();
TupleSets<RightTuple> rightTuples = bm.getStagedRightTuples();
if (rightTuples.isEmpty()) {
bm.setNodeDirtyWithoutNotify();
}
rightTuples.addDelete(rightTuple);
if (bns != null) {
// Add peered RightTuples, they are attached to FH - unlink LeftTuples that has a peer ref
for (int i = 0; i < length; i++) {
rightTuple = rightTuple.getHandleNext();
rightTuples = bms[i].getStagedRightTuples();
if (rightTuples.isEmpty()) {
bms[i].setNodeDirtyWithoutNotify();
}
rightTuples.addDelete(rightTuple);
}
}
leftTuple.clearStaged();
leftTuple = next;
}
for (LeftTuple leftTuple = srcTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
InternalFactHandle handle = (InternalFactHandle) leftTuple.getContextObject();
RightTuple rightTuple = handle.getFirstRightTuple();
TupleSets<RightTuple> rightTuples = bm.getStagedRightTuples();
if (rightTuples.isEmpty()) {
bm.setNodeDirtyWithoutNotify();
}
rightTuples.addUpdate(rightTuple);
if (bns != null) {
// Add peered RightTuples, they are attached to FH - unlink LeftTuples that has a peer ref
for (int i = 0; i < length; i++) {
rightTuple = rightTuple.getHandleNext();
rightTuples = bms[i].getStagedRightTuples();
if (rightTuples.isEmpty()) {
bms[i].setNodeDirtyWithoutNotify();
}
rightTuples.addUpdate(rightTuple);
}
}
leftTuple.clearStaged();
leftTuple = next;
}
srcTuples.resetAll();
}
public void doRightUpdates(
NotNode notNode,
LeftTupleSink sink,
BetaMemory bm,
InternalWorkingMemory wm,
RightTupleSets srcRightTuples,
LeftTupleSets trgLeftTuples,
LeftTupleSets stagedLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
RightTupleMemory rtm = bm.getRightTupleMemory();
ContextEntry[] contextEntry = bm.getContext();
BetaConstraints constraints = notNode.getRawConstraints();
boolean iterateFromStart =
notNode.isIndexedUnificationJoin() || rtm.getIndexType().isComparison();
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
PropagationContext context = rightTuple.getPropagationContext();
constraints.updateFromFactHandle(contextEntry, wm, rightTuple.getFactHandle());
FastIterator leftIt = notNode.getLeftIterator(ltm);
LeftTuple firstLeftTuple = notNode.getFirstLeftTuple(rightTuple, ltm, context, leftIt);
LeftTuple firstBlocked = rightTuple.getTempBlocked();
// first process non-blocked tuples, as we know only those ones are in the left memory.
for (LeftTuple leftTuple = firstLeftTuple; leftTuple != null; ) {
// preserve next now, in case we remove this leftTuple
LeftTuple temp = (LeftTuple) leftIt.next(leftTuple);
if (leftTuple.getStagedType() == LeftTuple.UPDATE) {
// ignore, as it will get processed via left iteration. Children cannot be processed twice
leftTuple = temp;
continue;
}
// we know that only unblocked LeftTuples are still in the memory
if (constraints.isAllowedCachedRight(contextEntry, leftTuple)) {
leftTuple.setBlocker(rightTuple);
rightTuple.addBlocked(leftTuple);
// this is now blocked so remove from memory
ltm.remove(leftTuple);
LeftTuple childLeftTuple = leftTuple.getFirstChild();
if (childLeftTuple != null) {
childLeftTuple.setPropagationContext(rightTuple.getPropagationContext());
RuleNetworkEvaluator.deleteRightChild(childLeftTuple, trgLeftTuples, stagedLeftTuples);
}
}
leftTuple = temp;
}
if (firstBlocked != null) {
RightTuple rootBlocker = rightTuple.getTempNextRightTuple();
if (rootBlocker == null) {
iterateFromStart = true;
}
FastIterator rightIt = notNode.getRightIterator(rtm);
// iterate all the existing previous blocked LeftTuples
for (LeftTuple leftTuple = firstBlocked; leftTuple != null; ) {
LeftTuple temp = leftTuple.getBlockedNext();
leftTuple.clearBlocker();
if (leftTuple.getStagedType() == LeftTuple.UPDATE) {
// ignore, as it will get processed via left iteration. Children cannot be processed
// twice
// but need to add it back into list first
leftTuple.setBlocker(rightTuple);
rightTuple.addBlocked(leftTuple);
leftTuple = temp;
continue;
}
constraints.updateFromTuple(contextEntry, wm, leftTuple);
if (iterateFromStart) {
rootBlocker = notNode.getFirstRightTuple(leftTuple, rtm, null, rightIt);
}
// we know that older tuples have been checked so continue next
for (RightTuple newBlocker = rootBlocker;
newBlocker != null;
newBlocker = (RightTuple) rightIt.next(newBlocker)) {
// cannot select a RightTuple queued in the delete list
// There may be UPDATE RightTuples too, but that's ok. They've already been re-added to
// the correct bucket, safe to be reprocessed.
if (leftTuple.getStagedType() != LeftTuple.DELETE
&& newBlocker.getStagedType() != LeftTuple.DELETE
&& constraints.isAllowedCachedLeft(contextEntry, newBlocker.getFactHandle())) {
leftTuple.setBlocker(newBlocker);
newBlocker.addBlocked(leftTuple);
break;
}
}
if (leftTuple.getBlocker() == null) {
// was previous blocked and not in memory, so add
ltm.add(leftTuple);
// subclasses like ForallNotNode might override this propagation
trgLeftTuples.addInsert(
sink.createLeftTuple(leftTuple, sink, rightTuple.getPropagationContext(), true));
}
leftTuple = temp;
}
}
rightTuple.clearStaged();
rightTuple = next;
}
constraints.resetFactHandle(contextEntry);
constraints.resetTuple(contextEntry);
}
public void doRightInserts(
NotNode notNode,
BetaMemory bm,
InternalWorkingMemory wm,
RightTupleSets srcRightTuples,
LeftTupleSets trgLeftTuples,
LeftTupleSets stagedLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
RightTupleMemory rtm = bm.getRightTupleMemory();
ContextEntry[] contextEntry = bm.getContext();
BetaConstraints constraints = notNode.getRawConstraints();
// this must be processed here, rather than initial insert, as we need to link the blocker
unlinkNotNodeOnRightInsert(notNode, bm, wm);
for (RightTuple rightTuple = srcRightTuples.getInsertFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
rtm.add(rightTuple);
if (ltm == null || ltm.size() == 0) {
// do nothing here, as no left memory
rightTuple.clearStaged();
rightTuple = next;
continue;
}
FastIterator it = notNode.getLeftIterator(ltm);
PropagationContext context = rightTuple.getPropagationContext();
constraints.updateFromFactHandle(contextEntry, wm, rightTuple.getFactHandle());
for (LeftTuple leftTuple = notNode.getFirstLeftTuple(rightTuple, ltm, context, it);
leftTuple != null; ) {
// preserve next now, in case we remove this leftTuple
LeftTuple temp = (LeftTuple) it.next(leftTuple);
if (leftTuple.getStagedType() == LeftTuple.UPDATE) {
// ignore, as it will get processed via left iteration. Children cannot be processed twice
leftTuple = temp;
continue;
}
// we know that only unblocked LeftTuples are still in the memory
if (constraints.isAllowedCachedRight(contextEntry, leftTuple)) {
leftTuple.setBlocker(rightTuple);
rightTuple.addBlocked(leftTuple);
// this is now blocked so remove from memory
ltm.remove(leftTuple);
// subclasses like ForallNotNode might override this propagation
// ** @TODO (mdp) need to not break forall
LeftTuple childLeftTuple = leftTuple.getFirstChild();
if (childLeftTuple != null) { // NotNode only has one child
childLeftTuple.setPropagationContext(rightTuple.getPropagationContext());
RuleNetworkEvaluator.deleteLeftChild(childLeftTuple, trgLeftTuples, stagedLeftTuples);
}
}
leftTuple = temp;
}
rightTuple.clearStaged();
rightTuple = next;
}
constraints.resetFactHandle(contextEntry);
}
