1 files changed, 346 insertions, 0 deletions

diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/network/NodeProvisioner.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/network/NodeProvisioner.java
new file mode 100644
index 00000000..9121fc44
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/network/NodeProvisioner.java
@@ -0,0 +1,346 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.network;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.rete.boundary.InputConnector;
+import tools.refinery.viatra.runtime.rete.construction.plancompiler.CompilerHelper;
+import tools.refinery.viatra.runtime.rete.index.Indexer;
+import tools.refinery.viatra.runtime.rete.index.OnetimeIndexer;
+import tools.refinery.viatra.runtime.rete.index.ProjectionIndexer;
+import tools.refinery.viatra.runtime.rete.network.delayed.DelayedConnectCommand;
+import tools.refinery.viatra.runtime.rete.recipes.*;
+import tools.refinery.viatra.runtime.rete.recipes.helper.RecipeRecognizer;
+import tools.refinery.viatra.runtime.rete.recipes.helper.RecipesHelper;
+import tools.refinery.viatra.runtime.rete.remote.Address;
+import tools.refinery.viatra.runtime.rete.remote.RemoteReceiver;
+import tools.refinery.viatra.runtime.rete.remote.RemoteSupplier;
+import tools.refinery.viatra.runtime.rete.traceability.ActiveNodeConflictTrace;
+import tools.refinery.viatra.runtime.rete.traceability.RecipeTraceInfo;
+import tools.refinery.viatra.runtime.rete.traceability.UserRequestTrace;
+import tools.refinery.viatra.runtime.rete.util.Options;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Stores the internal parts of a rete network. Nodes are stored according to type and parameters.
+ *
+ * @author Gabor Bergmann
+ */
+public class NodeProvisioner {
+
+    // boolean activeStorage = true;
+
+    ReteContainer reteContainer;
+    NodeFactory nodeFactory;
+    ConnectionFactory connectionFactory;
+    InputConnector inputConnector;
+    IQueryRuntimeContext runtimeContext;
+
+    // TODO as recipe?
+    Map<Supplier, RemoteReceiver> remoteReceivers = CollectionsFactory.createMap();
+    Map<Address<? extends Supplier>, RemoteSupplier> remoteSuppliers = CollectionsFactory.createMap();
+
+    private RecipeRecognizer recognizer;
+
+    /**
+     * PRE: NodeFactory, ConnectionFactory must exist
+     *
+     * @param reteContainer
+     *            the ReteNet whose interior is to be mapped.
+     */
+    public NodeProvisioner(ReteContainer reteContainer) {
+        super();
+        this.reteContainer = reteContainer;
+        this.nodeFactory = reteContainer.getNodeFactory();
+        this.connectionFactory = reteContainer.getConnectionFactory();
+        this.inputConnector = reteContainer.getInputConnectionFactory();
+        runtimeContext = reteContainer.getNetwork().getEngine().getRuntimeContext();
+        recognizer = new RecipeRecognizer(runtimeContext);
+    }
+
+    public synchronized Address<? extends Node> getOrCreateNodeByRecipe(RecipeTraceInfo recipeTrace) {
+        ReteNodeRecipe recipe = recipeTrace.getRecipe();
+        Address<? extends Node> result = getNodesByRecipe().get(recipe);
+        if (result != null) {
+            // NODE ALREADY CONSTRUCTED FOR RECIPE, only needs to add trace
+            if (getRecipeTraces().add(recipeTrace))
+                result.getNodeCache().assignTraceInfo(recipeTrace);
+        } else {
+            // No node for this recipe object - but equivalent recipes still
+            // reusable
+            ReteNodeRecipe canonicalRecipe = recognizer.canonicalizeRecipe(recipe);
+            if (canonicalRecipe != recipe) {
+                // FOUND EQUIVALENT RECIPE
+                result = getNodesByRecipe().get(canonicalRecipe);
+                if (result != null) {
+                    // NODE ALREADY CONSTRUCTED FOR EQUIVALENT RECIPE
+                    recipeTrace.shadowWithEquivalentRecipe(canonicalRecipe);
+                    getNodesByRecipe().put(recipe, result);
+                    if (getRecipeTraces().add(recipeTrace))
+                        result.getNodeCache().assignTraceInfo(recipeTrace);
+                    // Bug 491922: ensure that recipe shadowing propagates to
+                    // parent traces
+                    // note that if equivalentRecipes() becomes more
+                    // sophisticated
+                    // and considers recipes with different parents, this might
+                    // have to be changed
+                    ensureParents(recipeTrace);
+                } else {
+                    // CONSTRUCTION IN PROGRESS FOR EQUIVALENT RECIPE
+                    if (recipe instanceof IndexerRecipe) {
+                        // this is allowed for indexers;
+                        // go on with the construction, as the same indexer node
+                        // will be obtained anyways
+                    } else {
+                        throw new IllegalStateException(
+                                "This should not happen: " + "non-indexer nodes are are supposed to be constructed "
+                                        + "as soon as they are designated as canonical recipes");
+                    }
+                }
+            }
+            if (result == null) {
+                // MUST INSTANTIATE NEW NODE FOR RECIPE
+                final Node freshNode = instantiateNodeForRecipe(recipeTrace, recipe);
+                result = reteContainer.makeAddress(freshNode);
+            }
+        }
+        return result;
+    }
+
+    private Set<RecipeTraceInfo> getRecipeTraces() {
+        return reteContainer.network.recipeTraces;
+    }
+
+    private Node instantiateNodeForRecipe(RecipeTraceInfo recipeTrace, final ReteNodeRecipe recipe) {
+        this.getRecipeTraces().add(recipeTrace);
+        if (recipe instanceof IndexerRecipe) {
+
+            // INSTANTIATE AND HOOK UP
+            // (cannot delay hooking up, because parent determines indexer
+            // implementation)
+            ensureParents(recipeTrace);
+            final ReteNodeRecipe parentRecipe = recipeTrace.getParentRecipeTraces().iterator().next().getRecipe();
+            final Indexer result = nodeFactory.createIndexer(reteContainer, (IndexerRecipe) recipe,
+                    asSupplier(
+                            (Address<? extends Supplier>) reteContainer.network.getExistingNodeByRecipe(parentRecipe)),
+                    recipeTrace);
+
+            // REMEMBER
+            if (Options.nodeSharingOption != Options.NodeSharingOption.NEVER) {
+                getNodesByRecipe().put(recipe, reteContainer.makeAddress(result));
+            }
+
+            return result;
+        } else {
+
+            // INSTANTIATE
+            Node result = nodeFactory.createNode(reteContainer, recipe, recipeTrace);
+
+            // REMEMBER
+            if (Options.nodeSharingOption == Options.NodeSharingOption.ALL) {
+                getNodesByRecipe().put(recipe, reteContainer.makeAddress(result));
+            }
+
+            // HOOK UP
+            // (recursion-tolerant due to this delayed order of initialization)
+            if (recipe instanceof InputRecipe) {
+                inputConnector.connectInput((InputRecipe) recipe, result);
+            } else {
+                if (recipe instanceof InputFilterRecipe)
+                    inputConnector.connectInputFilter((InputFilterRecipe) recipe, result);
+                ensureParents(recipeTrace);
+                connectionFactory.connectToParents(recipeTrace, result);
+            }
+            return result;
+        }
+    }
+
+    private Map<ReteNodeRecipe, Address<? extends Node>> getNodesByRecipe() {
+        return reteContainer.network.nodesByRecipe;
+    }
+
+    private void ensureParents(RecipeTraceInfo recipeTrace) {
+        for (RecipeTraceInfo parentTrace : recipeTrace.getParentRecipeTraces()) {
+            getOrCreateNodeByRecipe(parentTrace);
+        }
+    }
+
+    //// Remoting - TODO eliminate?
+
+    synchronized RemoteReceiver accessRemoteReceiver(Address<? extends Supplier> address) {
+        throw new UnsupportedOperationException("Multi-container Rete not supported yet");
+        // if (!reteContainer.isLocal(address))
+        // return
+        // address.getContainer().getProvisioner().accessRemoteReceiver(address);
+        // Supplier localSupplier = reteContainer.resolveLocal(address);
+        // RemoteReceiver result = remoteReceivers.get(localSupplier);
+        // if (result == null) {
+        // result = new RemoteReceiver(reteContainer);
+        // reteContainer.connect(localSupplier, result); // stateless node, no
+        // // synch required
+        //
+        // if (Options.nodeSharingOption != Options.NodeSharingOption.NEVER)
+        // remoteReceivers.put(localSupplier, result);
+        // }
+        // return result;
+    }
+
+    /**
+     * @pre: address is NOT local
+     */
+    synchronized RemoteSupplier accessRemoteSupplier(Address<? extends Supplier> address) {
+        throw new UnsupportedOperationException("Multi-container Rete not supported yet");
+        // RemoteSupplier result = remoteSuppliers.get(address);
+        // if (result == null) {
+        // result = new RemoteSupplier(reteContainer,
+        // address.getContainer().getProvisioner()
+        // .accessRemoteReceiver(address));
+        // // network.connectAndSynchronize(supplier, result);
+        //
+        // if (Options.nodeSharingOption != Options.NodeSharingOption.NEVER)
+        // remoteSuppliers.put(address, result);
+        // }
+        // return result;
+    }
+
+    /**
+     * The powerful method for accessing any (supplier) Address as a local supplier.
+     */
+    public Supplier asSupplier(Address<? extends Supplier> address) {
+        if (!reteContainer.isLocal(address))
+            return accessRemoteSupplier(address);
+        else
+            return reteContainer.resolveLocal(address);
+    }
+
+    /** the composite key tuple is formed as (RecipeTraceInfo, TupleMask) */
+    private Map<Tuple, UserRequestTrace> projectionIndexerUserRequests = CollectionsFactory.createMap();
+
+    // local version
+    // TODO remove?
+    public synchronized ProjectionIndexer accessProjectionIndexer(RecipeTraceInfo productionTrace, TupleMask mask) {
+        Tuple tableKey = Tuples.staticArityFlatTupleOf(productionTrace, mask);
+        UserRequestTrace indexerTrace = projectionIndexerUserRequests.computeIfAbsent(tableKey, k -> {
+            final ProjectionIndexerRecipe projectionIndexerRecipe = projectionIndexerRecipe(
+                    productionTrace, mask);
+            return new UserRequestTrace(projectionIndexerRecipe, productionTrace);
+        });
+        final Address<? extends Node> address = getOrCreateNodeByRecipe(indexerTrace);
+        return (ProjectionIndexer) reteContainer.resolveLocal(address);
+    }
+
+    // local version
+    public synchronized ProjectionIndexer accessProjectionIndexerOnetime(RecipeTraceInfo supplierTrace,
+            TupleMask mask) {
+        if (Options.nodeSharingOption != Options.NodeSharingOption.NEVER)
+            return accessProjectionIndexer(supplierTrace, mask);
+
+        final Address<? extends Node> supplierAddress = getOrCreateNodeByRecipe(supplierTrace);
+        Supplier supplier = (Supplier) reteContainer.resolveLocal(supplierAddress);
+
+        OnetimeIndexer result = new OnetimeIndexer(reteContainer, mask);
+        reteContainer.getDelayedCommandQueue().add(new DelayedConnectCommand(supplier, result, reteContainer));
+
+        return result;
+    }
+
+    // local, read-only version
+    public synchronized ProjectionIndexer peekProjectionIndexer(RecipeTraceInfo supplierTrace, TupleMask mask) {
+        final Address<? extends Node> address = getNodesByRecipe().get(projectionIndexerRecipe(supplierTrace, mask));
+        return address == null ? null : (ProjectionIndexer) reteContainer.resolveLocal(address);
+    }
+
+    private ProjectionIndexerRecipe projectionIndexerRecipe(
+            RecipeTraceInfo parentTrace, TupleMask mask) {
+        final ReteNodeRecipe parentRecipe = parentTrace.getRecipe();
+        Tuple tableKey = Tuples.staticArityFlatTupleOf(parentRecipe, mask);
+        ProjectionIndexerRecipe projectionIndexerRecipe = resultSeedRecipes.computeIfAbsent(tableKey, k ->
+            RecipesHelper.projectionIndexerRecipe(parentRecipe, CompilerHelper.toRecipeMask(mask))
+        );
+        return projectionIndexerRecipe;
+    }
+
+    /** the composite key tuple is formed as (ReteNodeRecipe, TupleMask) */
+    private Map<Tuple, ProjectionIndexerRecipe> resultSeedRecipes = CollectionsFactory.createMap();
+
+    // public synchronized Address<? extends Supplier>
+    // accessValueBinderFilterNode(
+    // Address<? extends Supplier> supplierAddress, int bindingIndex, Object
+    // bindingValue) {
+    // Supplier supplier = asSupplier(supplierAddress);
+    // Object[] paramsArray = { supplier.getNodeId(), bindingIndex, bindingValue
+    // };
+    // Tuple params = new FlatTuple(paramsArray);
+    // ValueBinderFilterNode result = valueBinderFilters.get(params);
+    // if (result == null) {
+    // result = new ValueBinderFilterNode(reteContainer, bindingIndex,
+    // bindingValue);
+    // reteContainer.connect(supplier, result); // stateless node, no synch
+    // // required
+    //
+    // if (Options.nodeSharingOption == Options.NodeSharingOption.ALL)
+    // valueBinderFilters.put(params, result);
+    // }
+    // return reteContainer.makeAddress(result);
+    // }
+
+    /**
+     * Returns a copy of the given indexer that is an active node by itself (created if does not exist). (Convention:
+     * attached with same mask to a transparent node that is attached to parent node.) Node is created if it does not
+     * exist yet.
+     *
+     * @return an identical but active indexer
+     */
+    // TODO rethink traceability
+    RecipeTraceInfo accessActiveIndexer(RecipeTraceInfo inactiveIndexerRecipeTrace) {
+        final RecipeTraceInfo parentRecipeTrace = inactiveIndexerRecipeTrace.getParentRecipeTraces().iterator().next();
+        final ProjectionIndexerRecipe inactiveIndexerRecipe = (ProjectionIndexerRecipe) inactiveIndexerRecipeTrace
+                .getRecipe();
+
+        final TransparentRecipe transparentRecipe = RecipesFactory.eINSTANCE.createTransparentRecipe();
+        transparentRecipe.setParent(parentRecipeTrace.getRecipe());
+        final ActiveNodeConflictTrace transparentRecipeTrace = new ActiveNodeConflictTrace(transparentRecipe,
+                parentRecipeTrace, inactiveIndexerRecipeTrace);
+
+        final ProjectionIndexerRecipe activeIndexerRecipe = RecipesFactory.eINSTANCE
+                .createProjectionIndexerRecipe();
+        activeIndexerRecipe.setParent(transparentRecipe);
+        activeIndexerRecipe.setMask(inactiveIndexerRecipe.getMask());
+        final ActiveNodeConflictTrace activeIndexerRecipeTrace = new ActiveNodeConflictTrace(activeIndexerRecipe,
+                transparentRecipeTrace, inactiveIndexerRecipeTrace);
+
+        return activeIndexerRecipeTrace;
+    }
+
+    // /**
+    // * @param parent
+    // * @return
+    // */
+    // private TransparentNode accessTransparentNodeInternal(Supplier parent) {
+    // nodeFactory.
+    // return null;
+    // }
+
+    // public synchronized void registerSpecializedProjectionIndexer(Node node,
+    // ProjectionIndexer indexer) {
+    // if (Options.nodeSharingOption != Options.NodeSharingOption.NEVER) {
+    // Object[] paramsArray = { node.getNodeId(), indexer.getMask() };
+    // Tuple params = new FlatTuple(paramsArray);
+    // projectionIndexers.put(params, indexer);
+    // }
+    // }
+
+}