Added configuration options and fixed some bugs

4 files changed, 62 insertions, 27 deletions

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreConfiguration.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreConfiguration.java
new file mode 100644
index 00000000..3dda98df
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreConfiguration.java
@@ -0,0 +1,19 @@
+package org.eclipse.viatra.solver.data.map;
+
+public class VersionedMapStoreConfiguration {
+        /**
+         * If true root is replaced with immutable node when committed.
+         * Frees up memory by releasing immutable nodes,
+         * but it may decrease performance by recreating immutable nodes upon changes (some evidence).
+         */
+        public boolean immutableWhenCommiting = true;
+        
+        /**
+         * If true, all subnodes are cached.
+         * It decreases the memory requirements.
+         * It may increase performance by discovering existing immutable copy of a node (some evidence).
+         * Additional overhead may decrease performance (no example found).
+         * The option permits the efficient implementation of version deletion.
+         */
+        public boolean sharedNodeCache = true;
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java
index b6a615ed..d9adc117 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java
@@ -10,20 +10,35 @@ import org.eclipse.viatra.solver.data.map.internal.Node;
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
 
 public class VersionedMapStoreImpl<KEY,VALUE> implements VersionedMapStore<KEY, VALUE> {
+        // Configuration
+        final private boolean immutableWhenCommiting;
+        
+        // Static data
         protected final ContinousHashProvider<? super KEY> hashProvider;
         protected final VALUE defaultValue;
         
+        // Dynamic data
         final protected Map<Long, ImmutableNode<KEY,VALUE>> states;
         final protected Map<Node<KEY,VALUE>, ImmutableNode<KEY,VALUE>> nodeCache;
         protected long nextID;
         
-        public VersionedMapStoreImpl(ContinousHashProvider<? super KEY> hashProvider, VALUE defaultValue) {
+        public VersionedMapStoreImpl(ContinousHashProvider<? super KEY> hashProvider, VALUE defaultValue, VersionedMapStoreConfiguration config) {
+                this.immutableWhenCommiting = config.immutableWhenCommiting;
+                
                 this.hashProvider = hashProvider;
                 this.defaultValue = defaultValue;
                 
                 states = new HashMap<>();
                 nextID = 0;
-                nodeCache = new HashMap<>();
+                if(config.sharedNodeCache) {
+                        nodeCache = new HashMap<>();
+                } else {
+                        nodeCache = null;
+                }
+        }
+        
+        public VersionedMapStoreImpl(ContinousHashProvider<? super KEY> hashProvider, VALUE defaultValue) {
+                this(hashProvider,defaultValue,new VersionedMapStoreConfiguration());
         }
         
         synchronized Set<Long> getStates() {
@@ -64,7 +79,9 @@ public class VersionedMapStoreImpl<KEY,VALUE> implements VersionedMapStore<KEY,
                         "Map store run out of Id-s");
                 long id = nextID++;
                 this.states.put(id, immutable);
-                //mapToUpdateRoot.setRoot(immutable);
+                if(this.immutableWhenCommiting) {
+                        mapToUpdateRoot.setRoot(immutable);
+                }
                 return id;
         }
         
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java
index 49b98863..087c12a1 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java
@@ -34,7 +34,12 @@ public class ImmutableNode<KEY, VALUE> extends Node<KEY, VALUE> {
 
         /**
          * Constructor that copies a mutable node to an immutable.
-         * @param node
+         * 
+         * @param node  A mutable node.
+         * @param cache A cache of existing immutable nodes. It can be used to search
+         *              and place reference immutable nodes. It can be null, if no cache
+         *              available.
+         * @return an immutable version of the input node.
          */
         @SuppressWarnings("unchecked")
         static <KEY,VALUE> ImmutableNode<KEY,VALUE> constructImmutable(MutableNode<KEY,VALUE> node, Map<Node<KEY, VALUE>, ImmutableNode<KEY, VALUE>> cache) {
@@ -83,7 +88,9 @@ public class ImmutableNode<KEY, VALUE> extends Node<KEY, VALUE> {
                 ImmutableNode<KEY,VALUE> newImmutable = new ImmutableNode<>(resultDataMap, resultNodeMap, resultContent, resultHash);
                 
                 // 3. save new immutable.
-                cache.put(newImmutable, newImmutable);
+                if(cache != null) {
+                        cache.put(newImmutable, newImmutable);
+                }
                 return newImmutable;
         }
         
@@ -132,16 +139,16 @@ public class ImmutableNode<KEY, VALUE> extends Node<KEY, VALUE> {
                                 if(value == defaultValue) {
                                         // delete
                                         MutableNode<KEY, VALUE> mutable = this.toMutable();
-                                        mutable.removeEntry(selectedHashFragment);
-                                        return mutable;
+                                        Node<KEY, VALUE> result = mutable.removeEntry(selectedHashFragment);
+                                        return result;
                                 } else if(value == content[keyIndex+1]) {
                                         // dont change
                                         return this;
                                 } else {
                                         // update existing value
                                         MutableNode<KEY, VALUE> mutable = this.toMutable();
-                                        mutable.updateValue(value, selectedHashFragment);
-                                        return mutable;
+                                        Node<KEY, VALUE> result = mutable.updateValue(value, selectedHashFragment);
+                                        return result;
                                 }
                         } else {
                                 if(value == defaultValue) {
@@ -150,13 +157,13 @@ public class ImmutableNode<KEY, VALUE> extends Node<KEY, VALUE> {
                                 } else {
                                         // add new key + value
                                         MutableNode<KEY, VALUE> mutable = this.toMutable();
-                                        mutable.putValue(key, value, hashProvider, defaultValue, selectedHashFragment, depth);
-                                        return mutable;
+                                        Node<KEY, VALUE> result = mutable.putValue(key, value, hashProvider, defaultValue, hash, depth);
+                                        return result;
                                 }
                         }
                 } else if((nodeMap & bitposition)!=0) {
                         
-                        int keyIndex = content.length-1-index(dataMap, bitposition);
+                        int keyIndex = content.length-1-index(nodeMap, bitposition);
                         ImmutableNode<KEY,VALUE> subNode = (ImmutableNode<KEY,VALUE>) content[keyIndex];
                         int newDepth = depth+1;
                         int newHash = newHash(hashProvider, key, hash, newDepth);
@@ -166,15 +173,15 @@ public class ImmutableNode<KEY, VALUE> extends Node<KEY, VALUE> {
                                 // nothing changed
                                 return this;
                         } else {
-                                MutableNode<KEY, VALUE> result = toMutable();
-                                result.updateSubNode(selectedHashFragment, newsubNode);
+                                MutableNode<KEY, VALUE> mutable  = toMutable();
+                                Node<KEY, VALUE> result = mutable.updateSubNode(selectedHashFragment, newsubNode);
                                 return result;
                         }
                 } else {
                         // add new key + value
                         MutableNode<KEY, VALUE> mutable = this.toMutable();
-                        mutable.putValue(key, value, hashProvider, defaultValue, selectedHashFragment, depth);
-                        return mutable;
+                        Node<KEY, VALUE> result = mutable.putValue(key, value, hashProvider, defaultValue, hash, depth);
+                        return result;
                 }
         }
         
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/MutableNode.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/MutableNode.java
index eaded957..c81bf36f 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/MutableNode.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/MutableNode.java
@@ -42,11 +42,11 @@ public class MutableNode<KEY,VALUE> extends Node<KEY,VALUE> {
                 for(int i=0; i<factor; i++) {
                         int bitposition = 1 << i;
                         if((node.dataMap & bitposition) != 0) {
-                                content[2*i] = this.content[dataUsed*2];
-                                content[2*i+1] = this.content[dataUsed*2+1];
+                                content[2*i] = node.content[dataUsed*2];
+                                content[2*i+1] = node.content[dataUsed*2+1];
                                 dataUsed++;
                         } else if((node.nodeMap & bitposition) != 0) {
-                                content[2*i+1] = this.content[this.content.length-1-nodeUsed];
+                                content[2*i+1] = node.content[node.content.length-1-nodeUsed];
                                 nodeUsed++;
                         }
                 }
@@ -394,14 +394,6 @@ public class MutableNode<KEY,VALUE> extends Node<KEY,VALUE> {
                 return this.cachedHash;
         }
         
-        public void checkHashCodeConsistency() {
-                int oldHash = this.hashCode();
-                updateHash();
-                int newHash = this.hashCode();
-                if(oldHash != newHash) {
-                        throw new IllegalStateException("Inconsistent hash code!");
-                }
-        }
         
         @Override
         public boolean equals(Object obj) {