You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kie.apache.org by ma...@apache.org on 2025/09/01 06:34:58 UTC
(incubator-kie-drools) branch main updated: [NO ISSUE] Clean up RuntimeSegmentUtilities (#6438)
This is an automated email from the ASF dual-hosted git repository.
mariofusco pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-kie-drools.git
The following commit(s) were added to refs/heads/main by this push:
new fd6cb19546 [NO ISSUE] Clean up RuntimeSegmentUtilities (#6438)
fd6cb19546 is described below
commit fd6cb195464af9ee33a5eee06fce6cd67d4fdc86
Author: Paolo Bizzarri <pi...@gmail.com>
AuthorDate: Mon Sep 1 08:34:53 2025 +0200
[NO ISSUE] Clean up RuntimeSegmentUtilities (#6438)
* Cleanup of segment memories
* Fixed order of parameters
---
.../main/java/org/drools/core/common/Memory.java | 2 +-
.../org/drools/core/phreak/EagerPhreakBuilder.java | 6 +-
.../org/drools/core/phreak/LazyPhreakBuilder.java | 162 ++++++++++-----------
.../org/drools/core/phreak/PropagationEntry.java | 2 +-
.../drools/core/phreak/RuleNetworkEvaluator.java | 4 +-
.../core/phreak/RuntimeSegmentUtilities.java | 32 ++--
.../org/drools/core/phreak/SegmentPropagator.java | 2 +-
.../drools/core/reteoo/LeftInputAdapterNode.java | 12 +-
.../kiesession/NodeSegmentUnlinkingTest.java | 6 +-
.../org/drools/kiesession/RuleUnlinkingTest.java | 4 +-
.../RuleUnlinkingWithSegmentMemoryTest.java | 8 +-
.../drools/mvel/integrationtests/LinkingTest.java | 6 +-
12 files changed, 123 insertions(+), 123 deletions(-)
diff --git a/drools-core/src/main/java/org/drools/core/common/Memory.java b/drools-core/src/main/java/org/drools/core/common/Memory.java
index 5fc3465a01..6bdbcddbff 100644
--- a/drools-core/src/main/java/org/drools/core/common/Memory.java
+++ b/drools-core/src/main/java/org/drools/core/common/Memory.java
@@ -35,7 +35,7 @@ public interface Memory extends DoubleLinkedEntry<Memory> {
default SegmentMemory getOrCreateSegmentMemory( LeftTupleSource tupleSource, ReteEvaluator reteEvaluator ) {
SegmentMemory smem = getSegmentMemory();
if (smem == null) {
- smem = RuntimeSegmentUtilities.getOrCreateSegmentMemory(this, tupleSource, reteEvaluator);
+ smem = RuntimeSegmentUtilities.getOrCreateSegmentMemory(reteEvaluator, tupleSource, this);
}
return smem;
}
diff --git a/drools-core/src/main/java/org/drools/core/phreak/EagerPhreakBuilder.java b/drools-core/src/main/java/org/drools/core/phreak/EagerPhreakBuilder.java
index ae6ca70dd6..3f6feddaac 100644
--- a/drools-core/src/main/java/org/drools/core/phreak/EagerPhreakBuilder.java
+++ b/drools-core/src/main/java/org/drools/core/phreak/EagerPhreakBuilder.java
@@ -147,7 +147,7 @@ public class EagerPhreakBuilder implements PhreakBuilder {
PathMemory pmem = (PathMemory) wm.getNodeMemories().peekNodeMemory(tn);
if (pmem != null) {
List<LeftTupleNode> splits = exclBranchRoots.stream().map( pair -> pair.parent).filter(Objects::nonNull).collect(Collectors.toList());
- LazyPhreakBuilder.flushStagedTuples(tn, pmem, splits, wm);
+ LazyPhreakBuilder.flushStagedTuples(wm, tn, pmem, splits);
}
}
@@ -849,12 +849,12 @@ public class EagerPhreakBuilder implements PhreakBuilder {
if ( sm1 == null) {
// To be able to merge sm1 must exist
- sm1 = RuntimeSegmentUtilities.getOrCreateSegmentMemory(proto1.getRootNode(), wm);
+ sm1 = RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, proto1.getRootNode());
}
if ( sm2 == null) {
// To be able to merge sm2 must exist
- sm2 = RuntimeSegmentUtilities.getOrCreateSegmentMemory(proto2.getRootNode(), wm);
+ sm2 = RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, proto2.getRootNode());
}
// merge the memories and reassign back to sm1
diff --git a/drools-core/src/main/java/org/drools/core/phreak/LazyPhreakBuilder.java b/drools-core/src/main/java/org/drools/core/phreak/LazyPhreakBuilder.java
index a910979812..0fa56f7dc8 100644
--- a/drools-core/src/main/java/org/drools/core/phreak/LazyPhreakBuilder.java
+++ b/drools-core/src/main/java/org/drools/core/phreak/LazyPhreakBuilder.java
@@ -135,7 +135,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
if (NodeTypeEnums.isLeftInputAdapterNode(firstSplit) && firstSplit.getAssociatedTerminalsSize() == 1) {
// rule added with no sharing
- insertLiaFacts(firstSplit, wm);
+ insertLiaFacts(wm, firstSplit);
} else {
PathEndNodeMemories tnms = getPathEndMemories(wm, pathEndNodes);
@@ -147,13 +147,13 @@ class LazyPhreakBuilder implements PhreakBuilder {
Map<PathMemory, SegmentMemory[]> prevSmemsLookup = reInitPathMemories(tnms.otherPmems, null);
// must collect all visited SegmentMemories, for link notification
- Set<SegmentMemory> smemsToNotify = handleExistingPaths(tn, prevSmemsLookup, tnms.otherPmems, wm, ExistingPathStrategy.ADD_STRATEGY);
+ Set<SegmentMemory> smemsToNotify = handleExistingPaths(wm, tn, prevSmemsLookup, tnms.otherPmems, ExistingPathStrategy.ADD_STRATEGY);
addNewPaths(wm, smemsToNotify, tnms.subjectPmems);
- processLeftTuples(firstSplit, wm, true, rule);
+ processLeftTuples(wm, rule, firstSplit, true);
- notifySegments(smemsToNotify, wm);
+ notifySegments(wm, smemsToNotify);
}
}
@@ -195,25 +195,25 @@ class LazyPhreakBuilder implements PhreakBuilder {
if ( !tnms.subjectPmems.isEmpty() ) {
if (NodeTypeEnums.isLeftInputAdapterNode(firstSplit) && firstSplit.getAssociatedTerminalsSize() == 1) {
if (tnms.subjectPmem != null) {
- flushStagedTuples(firstSplit, tnms.subjectPmem, wm);
+ flushStagedTuples(wm, firstSplit, tnms.subjectPmem);
}
- processLeftTuples(firstSplit, wm, false, tn.getRule());
+ processLeftTuples(wm, tn.getRule(), firstSplit, false);
removeNewPaths(wm, tnms.subjectPmems);
} else {
- flushStagedTuples(tn, tnms.subjectPmem, pathEndNodes.subjectSplits, wm);
+ flushStagedTuples(wm, tn, tnms.subjectPmem, pathEndNodes.subjectSplits);
- processLeftTuples(firstSplit, wm, false, tn.getRule());
+ processLeftTuples(wm, tn.getRule(), firstSplit, false);
removeNewPaths(wm, tnms.subjectPmems);
Map<PathMemory, SegmentMemory[]> prevSmemsLookup = reInitPathMemories(tnms.otherPmems, tn);
// must collect all visited SegmentMemories, for link notification
- Set<SegmentMemory> smemsToNotify = handleExistingPaths(tn, prevSmemsLookup, tnms.otherPmems, wm, ExistingPathStrategy.REMOVE_STRATEGY);
+ Set<SegmentMemory> smemsToNotify = handleExistingPaths(wm, tn, prevSmemsLookup, tnms.otherPmems, ExistingPathStrategy.REMOVE_STRATEGY);
- notifySegments(smemsToNotify, wm);
+ notifySegments(wm, smemsToNotify);
}
}
@@ -275,7 +275,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
SegmentMemory sm2 = nodeToSegmentMap.get(node);
if (sm2 == null) {
SegmentMemory sm1 = smems[smemIndex - 1];
- correctMemoryOnSplitsChanged(parentNode, null, wm);
+ correctMemoryOnSplitsChanged(wm, parentNode, null);
sm2 = splitSegment(wm, sm1, parentNode);
nodeToSegmentMap.put(node, sm2);
smemsToNotify.add(sm1);
@@ -336,7 +336,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
return;
}
- correctMemoryOnSplitsChanged(parentNode, tn, wm);
+ correctMemoryOnSplitsChanged(wm, parentNode, tn);
SegmentMemory sm1 = smems[smemIndex];
SegmentMemory sm2 = prevSmems[prevSmemIndex];
@@ -399,8 +399,8 @@ class LazyPhreakBuilder implements PhreakBuilder {
}
}
- private static Set<SegmentMemory> handleExistingPaths(TerminalNode tn, Map<PathMemory, SegmentMemory[]> prevSmemsLookup,
- List<PathMemory> pmems, InternalWorkingMemory wm, ExistingPathStrategy strategy) {
+ private static Set<SegmentMemory> handleExistingPaths(InternalWorkingMemory wm, TerminalNode tn,
+ Map<PathMemory, SegmentMemory[]> prevSmemsLookup, List<PathMemory> pmems, ExistingPathStrategy strategy) {
Set<SegmentMemory> smemsToNotify = new HashSet<>();
Set<SegmentMemory> visitedSegments = new HashSet<>();
Set<LeftTupleNode> visitedNodes = new HashSet<>();
@@ -443,7 +443,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
smemsToNotify, nodeToSegmentMap, wm);
smemSplitAdjustAmount++;
}
- checkEagerSegmentCreation(parentNode, wm, nodeTypesInSegment );
+ checkEagerSegmentCreation(wm, parentNode, nodeTypesInSegment );
nodeTypesInSegment = 0;
}
} while (!NodeTypeEnums.isEndNode(node));
@@ -481,7 +481,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
smemsToNotify.add( childSmem );
}
}
- correctMemoryOnSplitsChanged( parent, null, wm );
+ correctMemoryOnSplitsChanged( wm, parent, null );
}
} else {
Memory mem = wm.getNodeMemories().peekNodeMemory( child );
@@ -523,7 +523,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
while (true) {
if (child.getAssociatedTerminalsSize() == 1 && NodeTypeEnums.isBetaNode(child)) {
// If this is a beta node, it'll delete all the right input data
- deleteRightInputData((LeftTupleSink) child, wm);
+ deleteRightInputData(wm, (LeftTupleSink) child);
}
if (parent != null && parent.getAssociatedTerminalsSize() != 1 && child.getAssociatedTerminalsSize() == 1) {
@@ -581,7 +581,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
}
}
- public static void flushStagedTuples(TerminalNode tn, PathMemory pmem, List<LeftTupleNode> splits, InternalWorkingMemory wm) {
+ public static void flushStagedTuples(InternalWorkingMemory wm, TerminalNode tn, PathMemory pmem, List<LeftTupleNode> splits) {
// first flush the subject rule, then flush any staging lists that are part of a merge
if ( pmem.isInitialized() ) {
RuleNetworkEvaluator.INSTANCE.evaluateNetwork(pmem, pmem.getRuleAgendaItem().getRuleExecutor(), wm);
@@ -623,7 +623,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
}
}
- private static void flushStagedTuples(LeftTupleNode splitStartNode, PathMemory pmem, InternalWorkingMemory wm) {
+ private static void flushStagedTuples(InternalWorkingMemory wm, LeftTupleNode splitStartNode, PathMemory pmem) {
if ( !pmem.isInitialized() ) {
// The rule has never been linked in and evaluated, so there will be nothing to flush.
return;
@@ -666,13 +666,13 @@ class LazyPhreakBuilder implements PhreakBuilder {
return previousSmems;
}
- private static void notifySegments(Set<SegmentMemory> smems, InternalWorkingMemory wm) {
+ private static void notifySegments(InternalWorkingMemory wm, Set<SegmentMemory> smems) {
for (SegmentMemory sm : smems) {
sm.notifyRuleLinkSegment(wm);
}
}
- private static void correctMemoryOnSplitsChanged(LeftTupleNode splitStart, TerminalNode removingTN, InternalWorkingMemory wm) {
+ private static void correctMemoryOnSplitsChanged(InternalWorkingMemory wm, LeftTupleNode splitStart, TerminalNode removingTN) {
if (splitStart.getType() == NodeTypeEnums.QueryElementNode) {
QueryElementNode.QueryElementNodeMemory mem = (QueryElementNode.QueryElementNodeMemory) wm.getNodeMemories().peekNodeMemory(splitStart);
if (mem != null) {
@@ -707,7 +707,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
return counter;
}
- private static void insertLiaFacts(LeftTupleNode startNode, InternalWorkingMemory wm) {
+ private static void insertLiaFacts(InternalWorkingMemory wm, LeftTupleNode startNode) {
// rule added with no sharing
PropagationContextFactory pctxFactory = RuntimeComponentFactory.get().getPropagationContextFactory();
final PropagationContext pctx = pctxFactory.createPropagationContext(wm.getNextPropagationIdCounter(), PropagationContext.Type.RULE_ADDITION, null, null, null);
@@ -738,7 +738,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
}
}
- private static void deleteRightInputData(LeftTupleSink node, InternalWorkingMemory wm) {
+ private static void deleteRightInputData(InternalWorkingMemory wm, LeftTupleSink node) {
if (wm.getNodeMemories().peekNodeMemory(node) != null) {
BetaNode bn = (BetaNode) node;
BetaMemory bm;
@@ -766,11 +766,11 @@ class LazyPhreakBuilder implements PhreakBuilder {
unlinkRightTuples(srcRightTuples.getUpdateFirst());
unlinkRightTuples(srcRightTuples.getDeleteFirst());
- deleteFactsFromRightInput(bn, wm);
+ deleteFactsFromRightInput(wm, bn);
}
}
- private static void deleteFactsFromRightInput(BetaNode bn, InternalWorkingMemory wm) {
+ private static void deleteFactsFromRightInput(InternalWorkingMemory wm, BetaNode bn) {
ObjectSource source = bn.getRightInput();
if (source.getType() == NodeTypeEnums.WindowNode) {
WindowNode.WindowMemory memory = wm.getNodeMemory(((WindowNode) source));
@@ -800,7 +800,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
* It traverses to the LiaNode's ObjectTypeNode. It then iterates the LeftTuple chains, where an existing LeftTuple is staged
* as delete. Or a new LeftTuple is created and staged as an insert.
*/
- private static void processLeftTuples(LeftTupleNode node, InternalWorkingMemory wm, boolean insert, Rule rule) {
+ private static void processLeftTuples(InternalWorkingMemory wm, Rule rule, LeftTupleNode node, boolean insert) {
// *** if you make a fix here, it most likely needs to be in PhreakActivationIteratorToo ***
// Must iterate up until a node with memory is found, this can be followed to find the LeftTuples
@@ -829,7 +829,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
Tuple lt = BetaNode.getFirstTuple(bm.getLeftTupleMemory(), it);
for (; lt != null; lt = (TupleImpl) it.next(lt)) {
AccumulateContext accctx = (AccumulateContext) lt.getContextObject();
- visitChild( (TupleImpl) accctx.getResultLeftTuple(), insert, wm, rule);
+ visitChild( wm, rule, (TupleImpl) accctx.getResultLeftTuple(), insert);
}
} else if (NodeTypeEnums.ExistsNode == node.getType() && !node.isRightInputIsRiaNode()) { // do not process exists with subnetworks
// If there is a subnetwork, then there is no populated RTM, but the LTM is populated,
@@ -839,14 +839,14 @@ class LazyPhreakBuilder implements PhreakBuilder {
FastIterator it = bm.getRightTupleMemory().fullFastIterator(); // done off the RightTupleMemory, as exists only have unblocked tuples on the left side
for (RightTuple rt = (RightTuple) BetaNode.getFirstTuple(bm.getRightTupleMemory(), it); rt != null; rt = (RightTuple) it.next(rt)) {
for (LeftTuple lt = rt.getBlocked(); lt != null; lt = lt.getBlockedNext()) {
- visitLeftTuple(wm, insert, rule, lt);
+ visitLeftTuple(wm, rule, lt, insert);
}
}
} else {
bm = (BetaMemory) wm.getNodeMemory((MemoryFactory) node);
FastIterator it = bm.getLeftTupleMemory().fullFastIterator();
for (TupleImpl lt = (TupleImpl)BetaNode.getFirstTuple(bm.getLeftTupleMemory(), it); lt != null; lt = (TupleImpl) it.next(lt)) {
- visitLeftTuple(wm, insert, rule, lt);
+ visitLeftTuple(wm, rule, lt, insert);
}
}
return;
@@ -855,7 +855,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
TupleMemory ltm = fm.getBetaMemory().getLeftTupleMemory();
FastIterator it = ltm.fullFastIterator();
for (TupleImpl lt = ltm.getFirst(null); lt != null; lt = (TupleImpl) it.next(lt)) {
- visitChild(lt, insert, wm, rule);
+ visitChild(wm, rule, lt, insert);
}
return;
}
@@ -885,7 +885,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
// Each lt is for a different lian, skip any lian not associated with the rule. Need to use lt parent (souce) not child to check the lian.
if (SuperCacheFixer.getLeftTupleSource(lt).isAssociatedWith(rule)) {
- visitChild(lt, insert, wm, rule);
+ visitChild(wm, rule, lt, insert);
if (lt.getHandlePrevious() != null && nextLt != null) {
lt.getHandlePrevious().setHandleNext( nextLt );
@@ -896,16 +896,16 @@ class LazyPhreakBuilder implements PhreakBuilder {
}
}
- private static void visitLeftTuple(InternalWorkingMemory wm, boolean insert, Rule rule, TupleImpl lt) {
+ private static void visitLeftTuple(InternalWorkingMemory wm, Rule rule, TupleImpl lt, boolean insert) {
TupleImpl childLt = lt.getFirstChild();
while (childLt != null) {
TupleImpl nextLt = childLt.getHandleNext();
- visitChild(childLt, insert, wm, rule);
+ visitChild(wm, rule, childLt, insert);
childLt = nextLt;
}
}
- private static void visitChild(TupleImpl lt, boolean insert, InternalWorkingMemory wm, Rule rule) {
+ private static void visitChild(InternalWorkingMemory wm, Rule rule, TupleImpl lt, boolean insert) {
TupleImpl prevLt = null;
LeftTupleSinkNode sink = (LeftTupleSinkNode) lt.getSink();
@@ -917,18 +917,18 @@ class LazyPhreakBuilder implements PhreakBuilder {
if (lt.getSink().getAssociatedTerminalsSize() > 1) {
if (lt.getFirstChild() != null) {
for ( TupleImpl child = lt.getFirstChild(); child != null; child = child.getHandleNext() ) {
- visitChild(child, insert, wm, rule);
+ visitChild(wm, rule, child, insert);
}
} else if (lt.getSink().getType() == NodeTypeEnums.RightInputAdapterNode) {
- insertPeerRightTuple(lt, wm, rule, insert);
+ insertPeerRightTuple(wm, rule, lt, insert);
}
} else if (!insert) {
- iterateLeftTuple( lt, wm );
+ iterateLeftTuple( wm, lt );
TupleImpl lt2 = null;
for ( TupleImpl peerLt = lt.getPeer();
peerLt != null && peerLt.getSink().isAssociatedWith(rule) && peerLt.getSink().getAssociatedTerminalsSize() == 1;
peerLt = peerLt.getPeer() ) {
- iterateLeftTuple( peerLt, wm );
+ iterateLeftTuple( wm, peerLt );
lt2 = peerLt;
}
@@ -942,12 +942,12 @@ class LazyPhreakBuilder implements PhreakBuilder {
lt = lt.getPeer();
} else {
// there is a sink without a peer LT, so create the peer LT
- prevLt = insertPeerLeftTuple(prevLt, sink, wm, insert);
+ prevLt = insertPeerLeftTuple(wm, sink, prevLt, insert);
}
}
}
- private static void insertPeerRightTuple( TupleImpl lt, InternalWorkingMemory wm, Rule rule, boolean insert ) {
+ private static void insertPeerRightTuple( InternalWorkingMemory wm, Rule rule, TupleImpl lt, boolean insert ) {
// There's a shared RightInputAdaterNode, so check if one of its sinks is associated only to the new rule
TupleImpl prevLt = null;
RightInputAdapterNode rian = (RightInputAdapterNode) lt.getSink();
@@ -971,7 +971,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
/**
* Create all missing peers
*/
- private static TupleImpl insertPeerLeftTuple(TupleImpl lt, LeftTupleSinkNode node, InternalWorkingMemory wm, boolean insert) {
+ private static TupleImpl insertPeerLeftTuple(InternalWorkingMemory wm, LeftTupleSinkNode node, TupleImpl lt, boolean insert) {
TupleImpl peer = TupleFactory.createPeer(node, lt);
if ( node.getLeftTupleSource().getType() == NodeTypeEnums.AlphaTerminalNode ) {
@@ -1004,7 +1004,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
return peer;
}
- private static void iterateLeftTuple(TupleImpl lt, InternalWorkingMemory wm) {
+ private static void iterateLeftTuple(InternalWorkingMemory wm, TupleImpl lt) {
if (NodeTypeEnums.isTerminalNode(lt.getSink())) {
PathMemory pmem = (PathMemory) wm.getNodeMemories().peekNodeMemory( lt.getSink());
if (pmem != null) {
@@ -1014,14 +1014,14 @@ class LazyPhreakBuilder implements PhreakBuilder {
if (lt.getContextObject() instanceof AccumulateContext) {
TupleImpl resultLt = (TupleImpl) (( AccumulateContext ) lt.getContextObject()).getResultLeftTuple();
if (resultLt != null) {
- iterateLeftTuple( resultLt, wm );
+ iterateLeftTuple( wm, resultLt );
}
}
for (TupleImpl child = lt.getFirstChild(); child != null; child = child.getHandleNext()) {
for (TupleImpl peer = child; peer != null; peer = peer.getPeer()) {
if (peer.getPeer() == null) {
// it's unnnecessary to visit the unshared networks, so only iterate the last peer
- iterateLeftTuple( peer, wm );
+ iterateLeftTuple( wm, peer );
}
}
}
@@ -1346,7 +1346,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
// RTNS and RiaNode's have their own segment, if they are the child of a split.
createChildSegmentForTerminalNode( node, memory );
} else {
- createSegmentMemory((LeftTupleSource) node, reteEvaluator);
+ createSegmentMemory(reteEvaluator, (LeftTupleSource) node);
}
}
return memory.getSegmentMemory();
@@ -1357,7 +1357,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
Memory memory = reteEvaluator.getNodeMemory((MemoryFactory) segmentRoot);
return createChildSegmentForTerminalNode(segmentRoot, memory );
}
- return createSegmentMemory((LeftTupleSource) segmentRoot, reteEvaluator);
+ return createSegmentMemory(reteEvaluator, (LeftTupleSource) segmentRoot);
}
private static SegmentMemory createChildSegmentForTerminalNode( LeftTupleNode node, Memory memory ) {
@@ -1373,7 +1373,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
return childSmem;
}
- private static SegmentMemory createSegmentMemory(LeftTupleSource segmentRoot, ReteEvaluator reteEvaluator) {
+ private static SegmentMemory createSegmentMemory(ReteEvaluator reteEvaluator, LeftTupleSource segmentRoot) {
LeftTupleSource tupleSource = segmentRoot;
SegmentMemory smem = new SegmentMemory(segmentRoot);
@@ -1388,36 +1388,36 @@ class LazyPhreakBuilder implements PhreakBuilder {
while (true) {
nodeTypesInSegment = updateNodeTypesMask(tupleSource, nodeTypesInSegment);
if (NodeTypeEnums.isBetaNode(tupleSource)) {
- allLinkedTestMask = processBetaNode((BetaNode)tupleSource, reteEvaluator, smem, memories, nodePosMask, allLinkedTestMask, updateNodeBit);
+ allLinkedTestMask = processBetaNode(reteEvaluator, (BetaNode)tupleSource, smem, memories, nodePosMask, allLinkedTestMask, updateNodeBit);
} else {
switch (tupleSource.getType()) {
case NodeTypeEnums.LeftInputAdapterNode:
case NodeTypeEnums.AlphaTerminalNode:
- allLinkedTestMask = processLiaNode((LeftInputAdapterNode) tupleSource, reteEvaluator, smem, memories, nodePosMask, allLinkedTestMask);
+ allLinkedTestMask = processLiaNode(reteEvaluator, (LeftInputAdapterNode) tupleSource, smem, memories, nodePosMask, allLinkedTestMask);
break;
case NodeTypeEnums.EvalConditionNode:
- processEvalNode((EvalConditionNode) tupleSource, reteEvaluator, smem, memories);
+ processEvalNode(reteEvaluator, (EvalConditionNode) tupleSource, smem, memories);
break;
case NodeTypeEnums.ConditionalBranchNode:
- updateNodeBit = processBranchNode((ConditionalBranchNode) tupleSource, reteEvaluator, smem, memories);
+ updateNodeBit = processBranchNode(reteEvaluator, (ConditionalBranchNode) tupleSource, smem, memories);
break;
case NodeTypeEnums.FromNode:
- processFromNode((FromNode) tupleSource, reteEvaluator, smem, memories);
+ processFromNode(reteEvaluator, (FromNode) tupleSource, smem, memories);
break;
case NodeTypeEnums.ReactiveFromNode:
- processReactiveFromNode((MemoryFactory) tupleSource, reteEvaluator, smem, memories, nodePosMask);
+ processReactiveFromNode(reteEvaluator, (MemoryFactory) tupleSource, smem, memories, nodePosMask);
break;
case NodeTypeEnums.TimerConditionNode:
- processTimerNode((TimerNode) tupleSource, reteEvaluator, smem, memories, nodePosMask);
+ processTimerNode(reteEvaluator, (TimerNode) tupleSource, smem, memories, nodePosMask);
break;
case NodeTypeEnums.AsyncSendNode:
- processAsyncSendNode((AsyncSendNode) tupleSource, reteEvaluator, smem, memories);
+ processAsyncSendNode(reteEvaluator, (AsyncSendNode) tupleSource, smem, memories);
break;
case NodeTypeEnums.AsyncReceiveNode:
- processAsyncReceiveNode((AsyncReceiveNode) tupleSource, reteEvaluator, smem, memories, nodePosMask);
+ processAsyncReceiveNode(reteEvaluator, (AsyncReceiveNode) tupleSource, smem, memories, nodePosMask);
break;
case NodeTypeEnums.QueryElementNode:
- updateNodeBit = processQueryNode((QueryElementNode) tupleSource, reteEvaluator, segmentRoot, smem, memories, nodePosMask);
+ updateNodeBit = processQueryNode(reteEvaluator, (QueryElementNode) tupleSource, segmentRoot, smem, memories, nodePosMask);
break;
}
}
@@ -1441,7 +1441,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
ObjectSink[] nodes = rian.getObjectSinkPropagator().getSinks();
for ( ObjectSink node : nodes ) {
if ( NodeTypeEnums.isLeftTupleSource(node) ) {
- getOrCreateSegmentMemory( (LeftTupleSource) node, reteEvaluator );
+ getOrCreateSegmentMemory( reteEvaluator, (LeftTupleSource) node );
}
}
} else if (NodeTypeEnums.isTerminalNode(sink)) {
@@ -1486,14 +1486,14 @@ class LazyPhreakBuilder implements PhreakBuilder {
smem.setSegmentPosMaskBit(ruleSegmentPosMask);
smem.setPos(counter);
- updateRiaAndTerminalMemory(tupleSource, tupleSource, smem, reteEvaluator, false, nodeTypesInSegment);
+ updateRiaAndTerminalMemory(reteEvaluator, tupleSource, tupleSource, smem, false, nodeTypesInSegment);
reteEvaluator.getKnowledgeBase().registerSegmentPrototype(segmentRoot, smem.getSegmentPrototype().initFromSegmentMemory(smem));
return smem;
}
- private static boolean processQueryNode(QueryElementNode queryNode, ReteEvaluator reteEvaluator, LeftTupleSource segmentRoot, SegmentMemory smem, List<Memory> memories, long nodePosMask) {
+ private static boolean processQueryNode(ReteEvaluator reteEvaluator, QueryElementNode queryNode, LeftTupleSource segmentRoot, SegmentMemory smem, List<Memory> memories, long nodePosMask) {
// Initialize the QueryElementNode and have it's memory reference the actual query SegmentMemory
SegmentMemory querySmem = getQuerySegmentMemory(reteEvaluator, queryNode);
QueryElementNode.QueryElementNodeMemory queryNodeMem = smem.createNodeMemory(queryNode, reteEvaluator);
@@ -1504,33 +1504,33 @@ class LazyPhreakBuilder implements PhreakBuilder {
return ! queryNode.getQueryElement().isAbductive();
}
- private static void processFromNode(MemoryFactory tupleSource, ReteEvaluator reteEvaluator, SegmentMemory smem, List<Memory> memories) {
+ private static void processFromNode(ReteEvaluator reteEvaluator, MemoryFactory tupleSource, SegmentMemory smem, List<Memory> memories) {
Memory mem = smem.createNodeMemory(tupleSource, reteEvaluator);
memories.add(mem);
mem.setSegmentMemory(smem);
}
- private static void processAsyncSendNode(MemoryFactory tupleSource, ReteEvaluator reteEvaluator, SegmentMemory smem, List<Memory> memories) {
+ private static void processAsyncSendNode(ReteEvaluator reteEvaluator, MemoryFactory tupleSource, SegmentMemory smem, List<Memory> memories) {
Memory mem = smem.createNodeMemory(tupleSource, reteEvaluator);
mem.setSegmentMemory(smem);
memories.add(mem);
}
- private static void processAsyncReceiveNode(AsyncReceiveNode tupleSource, ReteEvaluator reteEvaluator, SegmentMemory smem, List<Memory> memories, long nodePosMask) {
+ private static void processAsyncReceiveNode(ReteEvaluator reteEvaluator, AsyncReceiveNode tupleSource, SegmentMemory smem, List<Memory> memories, long nodePosMask) {
AsyncReceiveNode.AsyncReceiveMemory tnMem = smem.createNodeMemory( tupleSource, reteEvaluator );
memories.add(tnMem);
tnMem.setNodePosMaskBit(nodePosMask);
tnMem.setSegmentMemory(smem);
}
- private static void processReactiveFromNode(MemoryFactory tupleSource, ReteEvaluator reteEvaluator, SegmentMemory smem, List<Memory> memories, long nodePosMask) {
+ private static void processReactiveFromNode(ReteEvaluator reteEvaluator, MemoryFactory tupleSource, SegmentMemory smem, List<Memory> memories, long nodePosMask) {
FromNode.FromMemory mem = ((FromNode.FromMemory) smem.createNodeMemory(tupleSource, reteEvaluator));
memories.add(mem);
mem.setSegmentMemory(smem);
mem.setNodePosMaskBit(nodePosMask);
}
- private static boolean processBranchNode(ConditionalBranchNode tupleSource, ReteEvaluator reteEvaluator, SegmentMemory smem, List<Memory> memories) {
+ private static boolean processBranchNode(ReteEvaluator reteEvaluator, ConditionalBranchNode tupleSource, SegmentMemory smem, List<Memory> memories) {
ConditionalBranchNode.ConditionalBranchMemory branchMem = smem.createNodeMemory(tupleSource, reteEvaluator);
memories.add(branchMem);
branchMem.setSegmentMemory(smem);
@@ -1538,20 +1538,20 @@ class LazyPhreakBuilder implements PhreakBuilder {
return false;
}
- private static void processEvalNode(EvalConditionNode tupleSource, ReteEvaluator reteEvaluator, SegmentMemory smem, List<Memory> memories) {
+ private static void processEvalNode(ReteEvaluator reteEvaluator, EvalConditionNode tupleSource, SegmentMemory smem, List<Memory> memories) {
EvalConditionNode.EvalMemory evalMem = smem.createNodeMemory(tupleSource, reteEvaluator);
memories.add(evalMem);
evalMem.setSegmentMemory(smem);
}
- private static void processTimerNode(TimerNode tupleSource, ReteEvaluator reteEvaluator, SegmentMemory smem, List<Memory> memories, long nodePosMask) {
+ private static void processTimerNode(ReteEvaluator reteEvaluator, TimerNode tupleSource, SegmentMemory smem, List<Memory> memories, long nodePosMask) {
TimerNode.TimerNodeMemory tnMem = smem.createNodeMemory( tupleSource, reteEvaluator );
memories.add(tnMem);
tnMem.setNodePosMaskBit(nodePosMask);
tnMem.setSegmentMemory(smem);
}
- private static long processLiaNode(LeftInputAdapterNode tupleSource, ReteEvaluator reteEvaluator, SegmentMemory smem, List<Memory> memories, long nodePosMask, long allLinkedTestMask) {
+ private static long processLiaNode(ReteEvaluator reteEvaluator, LeftInputAdapterNode tupleSource, SegmentMemory smem, List<Memory> memories, long nodePosMask, long allLinkedTestMask) {
LeftInputAdapterNode.LiaNodeMemory liaMemory = smem.createNodeMemory(tupleSource, reteEvaluator);
memories.add(liaMemory);
liaMemory.setSegmentMemory(smem);
@@ -1560,7 +1560,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
return allLinkedTestMask;
}
- private static long processBetaNode(BetaNode betaNode, ReteEvaluator reteEvaluator, SegmentMemory smem, List<Memory> memories, long nodePosMask, long allLinkedTestMask, boolean updateNodeBit) {
+ private static long processBetaNode(ReteEvaluator reteEvaluator, BetaNode betaNode, SegmentMemory smem, List<Memory> memories, long nodePosMask, long allLinkedTestMask, boolean updateNodeBit) {
BetaMemory bm;
if (NodeTypeEnums.AccumulateNode == betaNode.getType()) {
AccumulateNode.AccumulateMemory accMemory = ((AccumulateNode.AccumulateMemory) smem.createNodeMemory(betaNode, reteEvaluator));
@@ -1580,7 +1580,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
bm.setSegmentMemory(smem);
if (betaNode.isRightInputIsRiaNode()) {
- RightInputAdapterNode riaNode = createRiaSegmentMemory( betaNode, reteEvaluator );
+ RightInputAdapterNode riaNode = createRiaSegmentMemory( reteEvaluator, betaNode );
PathMemory riaMem = reteEvaluator.getNodeMemory(riaNode);
bm.setRiaRuleMemory((RiaPathMemory) riaMem);
@@ -1608,19 +1608,19 @@ class LazyPhreakBuilder implements PhreakBuilder {
* This is because the rianode only cares if all of it's segments are linked, then
* it sets the bit of node it is the right input for.
*/
- private static int updateRiaAndTerminalMemory( LeftTupleSource lt,
+ private static int updateRiaAndTerminalMemory( ReteEvaluator reteEvaluator,
+ LeftTupleSource lt,
LeftTupleSource originalLt,
SegmentMemory smem,
- ReteEvaluator reteEvaluator,
boolean fromPrototype,
int nodeTypesInSegment ) {
- nodeTypesInSegment = checkSegmentBoundary(lt, reteEvaluator, nodeTypesInSegment);
+ nodeTypesInSegment = checkSegmentBoundary(reteEvaluator, lt, nodeTypesInSegment);
PathMemory pmem = null;
for (LeftTupleSink sink : lt.getSinkPropagator().getSinks()) {
if (NodeTypeEnums.isLeftTupleSource(sink)) {
- nodeTypesInSegment = updateRiaAndTerminalMemory((LeftTupleSource) sink, originalLt, smem, reteEvaluator, fromPrototype, nodeTypesInSegment);
+ nodeTypesInSegment = updateRiaAndTerminalMemory(reteEvaluator, (LeftTupleSource) sink, originalLt, smem, fromPrototype, nodeTypesInSegment);
} else if (sink.getType() == NodeTypeEnums.RightInputAdapterNode) {
// Even though we don't add the pmem and smem together, all pmem's for all pathend nodes must be initialized
RightInputAdapterNode.RiaPathMemory riaMem = (RightInputAdapterNode.RiaPathMemory) reteEvaluator.getNodeMemory((MemoryFactory) sink);
@@ -1641,7 +1641,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
ObjectSink[] nodes = ((RightInputAdapterNode) sink).getObjectSinkPropagator().getSinks();
for ( ObjectSink node : nodes ) {
if ( NodeTypeEnums.isLeftTupleSource(node) ) {
- getOrCreateSegmentMemory( (LeftTupleSource) node, reteEvaluator );
+ getOrCreateSegmentMemory( reteEvaluator, (LeftTupleSource) node );
}
}
}
@@ -1657,7 +1657,7 @@ class LazyPhreakBuilder implements PhreakBuilder {
// not's can cause segments to be linked, and the rules need to be notified for evaluation
smem.notifyRuleLinkSegment(reteEvaluator);
}
- checkEagerSegmentCreation(sink.getLeftTupleSource(), reteEvaluator, nodeTypesInSegment);
+ checkEagerSegmentCreation(reteEvaluator, sink.getLeftTupleSource(), nodeTypesInSegment);
pmem = null;
}
}
@@ -1667,14 +1667,14 @@ class LazyPhreakBuilder implements PhreakBuilder {
private static void restoreSegmentFromPrototype(ReteEvaluator reteEvaluator, LeftTupleSource segmentRoot, int nodeTypesInSegment) {
SegmentMemory smem = reteEvaluator.getKnowledgeBase().createSegmentFromPrototype(reteEvaluator, segmentRoot);
if ( smem != null ) {
- updateRiaAndTerminalMemory(segmentRoot, segmentRoot, smem, reteEvaluator, true, nodeTypesInSegment);
+ updateRiaAndTerminalMemory(reteEvaluator, segmentRoot, segmentRoot, smem, true, nodeTypesInSegment);
}
}
- private static int checkSegmentBoundary(LeftTupleSource lt, ReteEvaluator reteEvaluator, int nodeTypesInSegment) {
+ private static int checkSegmentBoundary(ReteEvaluator reteEvaluator, LeftTupleSource lt, int nodeTypesInSegment) {
if ( isRootNode( lt, null ) ) {
// we are in a new child segment
- checkEagerSegmentCreation(lt.getLeftTupleSource(), reteEvaluator, nodeTypesInSegment);
+ checkEagerSegmentCreation(reteEvaluator, lt.getLeftTupleSource(), nodeTypesInSegment);
nodeTypesInSegment = 0;
}
return updateNodeTypesMask(lt, nodeTypesInSegment);
@@ -1700,12 +1700,12 @@ class LazyPhreakBuilder implements PhreakBuilder {
return false;
}
- public static void checkEagerSegmentCreation(LeftTupleSource lt, ReteEvaluator reteEvaluator, int nodeTypesInSegment) {
+ public static void checkEagerSegmentCreation(ReteEvaluator reteEvaluator, LeftTupleSource lt, int nodeTypesInSegment) {
// A Not node has to be eagerly initialized unless in its segment there is at least a join node
if ( isSet(nodeTypesInSegment, NOT_NODE_BIT) &&
!isSet(nodeTypesInSegment, JOIN_NODE_BIT) &&
!isSet(nodeTypesInSegment, REACTIVE_EXISTS_NODE_BIT) ) {
- getOrCreateSegmentMemory(lt, reteEvaluator);
+ getOrCreateSegmentMemory(reteEvaluator, lt);
}
}
}
diff --git a/drools-core/src/main/java/org/drools/core/phreak/PropagationEntry.java b/drools-core/src/main/java/org/drools/core/phreak/PropagationEntry.java
index 913d705ae2..b15bd92ba3 100644
--- a/drools-core/src/main/java/org/drools/core/phreak/PropagationEntry.java
+++ b/drools-core/src/main/java/org/drools/core/phreak/PropagationEntry.java
@@ -186,7 +186,7 @@ public interface PropagationEntry {
LeftInputAdapterNode lian = (LeftInputAdapterNode) lts;
LeftInputAdapterNode.LiaNodeMemory lmem = reteEvaluator.getNodeMemory( lian );
if ( lmem.getSegmentMemory() == null ) {
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(lmem, lts, reteEvaluator);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(reteEvaluator, lts, lmem);
}
LeftInputAdapterNode.doInsertObject( handle, pCtx, lian, reteEvaluator, lmem, false, queryObject.isOpen() );
diff --git a/drools-core/src/main/java/org/drools/core/phreak/RuleNetworkEvaluator.java b/drools-core/src/main/java/org/drools/core/phreak/RuleNetworkEvaluator.java
index 1a7b0d876f..643df2872c 100644
--- a/drools-core/src/main/java/org/drools/core/phreak/RuleNetworkEvaluator.java
+++ b/drools-core/src/main/java/org/drools/core/phreak/RuleNetworkEvaluator.java
@@ -287,7 +287,7 @@ public class RuleNetworkEvaluator {
// this is needed for subnetworks that feed into a parent network that has no right inputs,
// and may not yet be initialized
if ( smem.isEmpty() && !NodeTypeEnums.isTerminalNode(smem.getTipNode()) ) {
- RuntimeSegmentUtilities.createChildSegments(activationsManager.getReteEvaluator(), smem, smem.getTipNode().getSinkPropagator());
+ RuntimeSegmentUtilities.createChildSegments(activationsManager.getReteEvaluator(), smem.getTipNode().getSinkPropagator(), smem);
}
smem = smems[i];
@@ -447,7 +447,7 @@ public class RuleNetworkEvaluator {
if (node == smem.getTipNode()) {
// we are about to process the segment tip, allow it to merge insert/update/delete clashes
if ( smem.isEmpty() ) {
- RuntimeSegmentUtilities.createChildSegments(reteEvaluator, smem, ((LeftTupleSource) node).getSinkPropagator());
+ RuntimeSegmentUtilities.createChildSegments(reteEvaluator, ((LeftTupleSource) node).getSinkPropagator(), smem);
}
return smem.getFirst().getStagedLeftTuples().takeAll();
} else {
diff --git a/drools-core/src/main/java/org/drools/core/phreak/RuntimeSegmentUtilities.java b/drools-core/src/main/java/org/drools/core/phreak/RuntimeSegmentUtilities.java
index 4564a1c0b1..9d4f464aa5 100644
--- a/drools-core/src/main/java/org/drools/core/phreak/RuntimeSegmentUtilities.java
+++ b/drools-core/src/main/java/org/drools/core/phreak/RuntimeSegmentUtilities.java
@@ -47,14 +47,14 @@ public class RuntimeSegmentUtilities {
/**
* Initialises the NodeSegment memory for all nodes in the segment.
*/
- public static SegmentMemory getOrCreateSegmentMemory(LeftTupleNode node, ReteEvaluator reteEvaluator) {
- return getOrCreateSegmentMemory(reteEvaluator.getNodeMemory((MemoryFactory<? extends Memory>) node), node, reteEvaluator);
+ public static SegmentMemory getOrCreateSegmentMemory(ReteEvaluator reteEvaluator, LeftTupleNode node) {
+ return getOrCreateSegmentMemory(reteEvaluator, node, reteEvaluator.getNodeMemory((MemoryFactory<? extends Memory>) node));
}
/**
* Initialises the NodeSegment memory for all nodes in the segment.
*/
- public static SegmentMemory getOrCreateSegmentMemory(Memory memory, LeftTupleNode node, ReteEvaluator reteEvaluator) {
+ public static SegmentMemory getOrCreateSegmentMemory(ReteEvaluator reteEvaluator, LeftTupleNode node, Memory memory) {
SegmentMemory smem = memory.getSegmentMemory();
if ( smem != null ) {
return smem;
@@ -66,7 +66,7 @@ public class RuntimeSegmentUtilities {
smem = restoreSegmentFromPrototype(reteEvaluator, segmentRoot);
if ( smem != null ) {
if (NodeTypeEnums.isBetaNode(segmentRoot) && segmentRoot.isRightInputIsRiaNode()) {
- createRiaSegmentMemory((BetaNode) segmentRoot, reteEvaluator);
+ createRiaSegmentMemory(reteEvaluator, (BetaNode) segmentRoot);
}
return smem;
}
@@ -99,23 +99,23 @@ public class RuntimeSegmentUtilities {
SegmentMemory smem = reteEvaluator.getKnowledgeBase().createSegmentFromPrototype(reteEvaluator, proto);
- updateRiaAndTerminalMemory(smem, proto, reteEvaluator);
+ updateRiaAndTerminalMemory(reteEvaluator, smem, proto);
return smem;
}
public static SegmentMemory getQuerySegmentMemory(ReteEvaluator reteEvaluator, QueryElementNode queryNode) {
ObjectTypeNode queryOtn = reteEvaluator.getDefaultEntryPoint().getEntryPointNode().getQueryNode();
- LeftInputAdapterNode liaNode = getQueryLiaNode(queryNode.getQueryElement().getQueryName(), queryOtn);
+ LeftInputAdapterNode liaNode = getQueryLiaNode(queryOtn, queryNode.getQueryElement().getQueryName());
LiaNodeMemory liam = reteEvaluator.getNodeMemory(liaNode);
SegmentMemory querySmem = liam.getSegmentMemory();
if (querySmem == null) {
- querySmem = getOrCreateSegmentMemory(liam, liaNode, reteEvaluator);
+ querySmem = getOrCreateSegmentMemory(reteEvaluator, liaNode, liam);
}
return querySmem;
}
- static RightInputAdapterNode createRiaSegmentMemory( BetaNode betaNode, ReteEvaluator reteEvaluator ) {
+ static RightInputAdapterNode createRiaSegmentMemory( ReteEvaluator reteEvaluator, BetaNode betaNode ) {
RightInputAdapterNode riaNode = (RightInputAdapterNode) betaNode.getRightInput();
LeftTupleSource subnetworkLts = riaNode.getStartTupleSource();
@@ -124,12 +124,12 @@ public class RuntimeSegmentUtilities {
SegmentMemory subNetworkSegmentMemory = rootSubNetwokrMem.getSegmentMemory();
if (subNetworkSegmentMemory == null) {
// we need to stop recursion here
- getOrCreateSegmentMemory(rootSubNetwokrMem, subnetworkLts, reteEvaluator);
+ getOrCreateSegmentMemory(reteEvaluator, subnetworkLts, rootSubNetwokrMem);
}
return riaNode;
}
- public static void createChildSegments(ReteEvaluator reteEvaluator, SegmentMemory smem, LeftTupleSinkPropagator sinkProp) {
+ public static void createChildSegments(ReteEvaluator reteEvaluator, LeftTupleSinkPropagator sinkProp, SegmentMemory smem) {
if ( !smem.isEmpty() ) {
return; // this can happen when multiple threads are trying to initialize the segment
}
@@ -144,7 +144,7 @@ public class RuntimeSegmentUtilities {
public static SegmentMemory createChildSegment(ReteEvaluator reteEvaluator, LeftTupleNode node) {
Memory memory = reteEvaluator.getNodeMemory((MemoryFactory) node);
if (memory.getSegmentMemory() == null) {
- getOrCreateSegmentMemory(memory, node, reteEvaluator);
+ getOrCreateSegmentMemory(reteEvaluator, node, memory);
}
return memory.getSegmentMemory();
}
@@ -157,9 +157,9 @@ public class RuntimeSegmentUtilities {
* This is because the rianode only cares if all of it's segments are linked, then
* it sets the bit of node it is the right input for.
*/
- private static void updateRiaAndTerminalMemory(SegmentMemory smem,
- SegmentPrototype proto,
- ReteEvaluator reteEvaluator) {
+ private static void updateRiaAndTerminalMemory(ReteEvaluator reteEvaluator,
+ SegmentMemory smem,
+ SegmentPrototype proto) {
for (PathEndNode endNode : proto.getPathEndNodes()) {
if (!isInsideSubnetwork(endNode, proto)) {
// While SegmentPrototypes are added for entire path, for traversal reasons.
@@ -202,13 +202,13 @@ public class RuntimeSegmentUtilities {
if (pathEndNode.getEagerSegmentPrototypes() != null) {
for (SegmentPrototype eager : pathEndNode.getEagerSegmentPrototypes()) {
if ( pmem.getSegmentMemories()[eager.getPos()] == null) {
- getOrCreateSegmentMemory(eager.getRootNode(), reteEvaluator);
+ getOrCreateSegmentMemory(reteEvaluator, eager.getRootNode());
}
}
}
}
- private static LeftInputAdapterNode getQueryLiaNode(String queryName, ObjectTypeNode queryOtn) {
+ private static LeftInputAdapterNode getQueryLiaNode(ObjectTypeNode queryOtn, String queryName) {
for (ObjectSink sink : queryOtn.getObjectSinkPropagator().getSinks()) {
AlphaNode alphaNode = (AlphaNode) sink;
QueryNameConstraint nameConstraint = (QueryNameConstraint) alphaNode.getConstraint();
diff --git a/drools-core/src/main/java/org/drools/core/phreak/SegmentPropagator.java b/drools-core/src/main/java/org/drools/core/phreak/SegmentPropagator.java
index 9d7ef763b2..4761b71e46 100644
--- a/drools-core/src/main/java/org/drools/core/phreak/SegmentPropagator.java
+++ b/drools-core/src/main/java/org/drools/core/phreak/SegmentPropagator.java
@@ -44,7 +44,7 @@ public class SegmentPropagator {
LeftTupleSource source = ( LeftTupleSource ) sourceSegment.getTipNode();
if ( sourceSegment.isEmpty() ) {
- RuntimeSegmentUtilities.createChildSegments(reteEvaluator, sourceSegment, source.getSinkPropagator());
+ RuntimeSegmentUtilities.createChildSegments(reteEvaluator, source.getSinkPropagator(), sourceSegment);
}
processPeers(sourceSegment, leftTuples);
diff --git a/drools-core/src/main/java/org/drools/core/reteoo/LeftInputAdapterNode.java b/drools-core/src/main/java/org/drools/core/reteoo/LeftInputAdapterNode.java
index 55b6167d9f..8a340bb60b 100644
--- a/drools-core/src/main/java/org/drools/core/reteoo/LeftInputAdapterNode.java
+++ b/drools-core/src/main/java/org/drools/core/reteoo/LeftInputAdapterNode.java
@@ -176,8 +176,8 @@ public class LeftInputAdapterNode extends LeftTupleSource
// liaNode in its own segment and child segments not yet created
if ( sm.isEmpty() ) {
RuntimeSegmentUtilities.createChildSegments(reteEvaluator,
- sm,
- liaNode.getSinkPropagator());
+ liaNode.getSinkPropagator(),
+ sm);
}
sm = sm.getFirst(); // repoint to the child sm
}
@@ -268,8 +268,8 @@ public class LeftInputAdapterNode extends LeftTupleSource
// liaNode in it's own segment and child segments not yet created
if ( sm.isEmpty() ) {
RuntimeSegmentUtilities.createChildSegments(reteEvaluator,
- sm,
- liaNode.getSinkPropagator());
+ liaNode.getSinkPropagator(),
+ sm);
}
sm = sm.getFirst(); // repoint to the child sm
}
@@ -328,8 +328,8 @@ public class LeftInputAdapterNode extends LeftTupleSource
// liaNode in it's own segment and child segments not yet created
if ( sm.isEmpty() ) {
RuntimeSegmentUtilities.createChildSegments(reteEvaluator,
- sm,
- liaNode.getSinkPropagator());
+ liaNode.getSinkPropagator(),
+ sm);
}
sm = sm.getFirst(); // repoint to the child sm
}
diff --git a/drools-kiesession/src/test/java/org/drools/kiesession/NodeSegmentUnlinkingTest.java b/drools-kiesession/src/test/java/org/drools/kiesession/NodeSegmentUnlinkingTest.java
index 6fbaf0616a..f6793136a7 100644
--- a/drools-kiesession/src/test/java/org/drools/kiesession/NodeSegmentUnlinkingTest.java
+++ b/drools-kiesession/src/test/java/org/drools/kiesession/NodeSegmentUnlinkingTest.java
@@ -272,7 +272,7 @@ public class NodeSegmentUnlinkingTest {
StatefulKnowledgeSessionImpl ksession = (StatefulKnowledgeSessionImpl)kBase.newKieSession();
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(liaNode, ksession);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(ksession, liaNode);
liaNode.assertObject((InternalFactHandle) ksession.insert("str"), context, ksession);
@@ -305,7 +305,7 @@ public class NodeSegmentUnlinkingTest {
// Initialise from lian
StatefulKnowledgeSessionImpl ksession = (StatefulKnowledgeSessionImpl)kBase.newKieSession();
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(liaNode, ksession);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(ksession, liaNode);
InternalFactHandle fh1 = (InternalFactHandle) ksession.insert( "str1" );
n1.assertObject( fh1, context, ksession );
@@ -497,7 +497,7 @@ public class NodeSegmentUnlinkingTest {
InternalWorkingMemory wm) {
BetaMemory betaMemory = (BetaMemory) wm.getNodeMemory(node);
if ( betaMemory.getSegmentMemory() == null ) {
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(node, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, node);
}
return betaMemory;
diff --git a/drools-kiesession/src/test/java/org/drools/kiesession/RuleUnlinkingTest.java b/drools-kiesession/src/test/java/org/drools/kiesession/RuleUnlinkingTest.java
index 27b2a85fdb..cbd05125d4 100644
--- a/drools-kiesession/src/test/java/org/drools/kiesession/RuleUnlinkingTest.java
+++ b/drools-kiesession/src/test/java/org/drools/kiesession/RuleUnlinkingTest.java
@@ -321,7 +321,7 @@ public class RuleUnlinkingTest {
DefaultFactHandle f1 = (DefaultFactHandle) wm.insert( "test1" );
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(liaNode, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, liaNode);
liaNode.assertObject( f1, context, wm );
n1.assertObject( f1, context, wm );
n3.assertObject( f1, context, wm );
@@ -382,7 +382,7 @@ public class RuleUnlinkingTest {
InternalWorkingMemory wm) {
BetaMemory betaMemory = (BetaMemory) wm.getNodeMemory(node);
if ( betaMemory.getSegmentMemory() == null ) {
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(node, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, node);
}
return betaMemory;
diff --git a/drools-kiesession/src/test/java/org/drools/kiesession/RuleUnlinkingWithSegmentMemoryTest.java b/drools-kiesession/src/test/java/org/drools/kiesession/RuleUnlinkingWithSegmentMemoryTest.java
index 80bbeb9f26..86cb5209bb 100644
--- a/drools-kiesession/src/test/java/org/drools/kiesession/RuleUnlinkingWithSegmentMemoryTest.java
+++ b/drools-kiesession/src/test/java/org/drools/kiesession/RuleUnlinkingWithSegmentMemoryTest.java
@@ -223,12 +223,12 @@ public class RuleUnlinkingWithSegmentMemoryTest {
PathMemory rtn3Rs = wm.getNodeMemory( rtn3 );
// lian
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(lian, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, lian);
LeftInputAdapterNode.LiaNodeMemory lmem = wm.getNodeMemory( lian );
assertThat(lmem.getNodePosMaskBit()).isEqualTo(1);
// n1
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(n1, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, n1);
bm = (BetaMemory) wm.getNodeMemory(n1);
assertThat(bm.getNodePosMaskBit()).isEqualTo(2);
assertThat(bm.getSegmentMemory().getAllLinkedMaskTest()).isEqualTo(15);
@@ -262,7 +262,7 @@ public class RuleUnlinkingWithSegmentMemoryTest {
assertThat(list.contains(rtn3Rs)).isTrue();
// n4
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(n4, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, n4);
bm = (BetaMemory) wm.getNodeMemory(n4);
assertThat(bm.getNodePosMaskBit()).isEqualTo(1);
assertThat(bm.getSegmentMemory().getAllLinkedMaskTest()).isEqualTo(3);
@@ -283,7 +283,7 @@ public class RuleUnlinkingWithSegmentMemoryTest {
assertThat(list.contains(rtn3Rs)).isTrue();
// n6
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(n6, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, n6);
bm = (BetaMemory) wm.getNodeMemory(n6);
assertThat(bm.getNodePosMaskBit()).isEqualTo(1);
assertThat(bm.getSegmentMemory().getAllLinkedMaskTest()).isEqualTo(7);
diff --git a/drools-test-coverage/test-compiler-integration/src/test/java/org/drools/mvel/integrationtests/LinkingTest.java b/drools-test-coverage/test-compiler-integration/src/test/java/org/drools/mvel/integrationtests/LinkingTest.java
index 04a73eb3e3..e69fc525aa 100644
--- a/drools-test-coverage/test-compiler-integration/src/test/java/org/drools/mvel/integrationtests/LinkingTest.java
+++ b/drools-test-coverage/test-compiler-integration/src/test/java/org/drools/mvel/integrationtests/LinkingTest.java
@@ -423,7 +423,7 @@ public class LinkingTest {
JoinNode eNode = ( JoinNode ) exists1n.getSinkPropagator().getSinks()[0];
RuleTerminalNode rtn = ( RuleTerminalNode ) eNode.getSinkPropagator().getSinks()[0];
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(exists1n, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, exists1n);
BetaMemory existsBm = (BetaMemory) wm.getNodeMemory(exists1n);
assertThat(existsBm.getSegmentMemory().getLinkedNodeMask()).isEqualTo(0);
@@ -1039,7 +1039,7 @@ public class LinkingTest {
NotNode bNode = ( NotNode) aNode.getSinkPropagator().getSinks()[0];
JoinNode cNode = ( JoinNode) bNode.getSinkPropagator().getSinks()[0];
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(cNode, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, cNode);
LiaNodeMemory amem = wm.getNodeMemory(aNode);
// Only NotNode is linked in
@@ -1116,7 +1116,7 @@ public class LinkingTest {
NotNode bNode = ( NotNode) aNode.getSinkPropagator().getSinks()[0];
JoinNode cNode = ( JoinNode) bNode.getSinkPropagator().getSinks()[0];
- RuntimeSegmentUtilities.getOrCreateSegmentMemory(cNode, wm);
+ RuntimeSegmentUtilities.getOrCreateSegmentMemory(wm, cNode);
LiaNodeMemory amem = wm.getNodeMemory(aNode);
// Only NotNode is linked in
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@kie.apache.org
For additional commands, e-mail: commits-help@kie.apache.org