Config updated and createSharedVersionedMapStores service

2 files changed, 72 insertions, 12 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
index 3dda98df..196adf2c 100644
--- 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
@@ -2,18 +2,26 @@ 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).
+         * 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 within a {@link VersionedMapStore}. 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 sharedNodeCacheInStore = 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.
+         * If true, all subnodes are cached within a group of
+         * {@link VersionedMapStoreImpl#createSharedVersionedMapStores(int, ContinousHashProvider, Object, VersionedMapStoreConfiguration)}.
+         * If {@link VersionedMapStoreConfiguration#sharedNodeCacheInStore} is
+         * <code>false</code>, then it has currently no impact.
          */
-        public boolean sharedNodeCache = true;
+        public boolean sharedNodeCacheInStoreGroups = 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 09607d4a..c551ffe7 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
@@ -3,6 +3,7 @@ package org.eclipse.viatra.solver.data.map;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
@@ -24,7 +25,11 @@ public class VersionedMapStoreImpl<KEY,VALUE> implements VersionedMapStore<KEY,
         final protected Map<Node<KEY,VALUE>, ImmutableNode<KEY,VALUE>> nodeCache;
         protected long nextID;
         
-        public VersionedMapStoreImpl(ContinousHashProvider<? super KEY> hashProvider, VALUE defaultValue, VersionedMapStoreConfiguration config) {
+        public VersionedMapStoreImpl(
+                ContinousHashProvider<? super KEY> hashProvider,
+                VALUE defaultValue,
+                VersionedMapStoreConfiguration config)
+        {
                 this.immutableWhenCommiting = config.immutableWhenCommiting;
                 
                 this.hashProvider = hashProvider;
@@ -32,17 +37,64 @@ public class VersionedMapStoreImpl<KEY,VALUE> implements VersionedMapStore<KEY,
                 
                 states = new HashMap<>();
                 nextID = 0;
-                if(config.sharedNodeCache) {
+                if(config.sharedNodeCacheInStore) {
                         nodeCache = new HashMap<>();
                 } else {
                         nodeCache = null;
                 }
         }
+        private VersionedMapStoreImpl(
+                ContinousHashProvider<? super KEY> hashProvider,
+                VALUE defaultValue,
+                Map<Node<KEY,VALUE>, ImmutableNode<KEY,VALUE>> nodeCache,
+                VersionedMapStoreConfiguration config)
+        {
+                this.immutableWhenCommiting = config.immutableWhenCommiting;
+                
+                this.hashProvider = hashProvider;
+                this.defaultValue = defaultValue;
+                
+                states = new HashMap<>();
+                nextID = 0;
+                this.nodeCache = nodeCache;
+        }
         
         public VersionedMapStoreImpl(ContinousHashProvider<KEY> hashProvider, VALUE defaultValue) {
                 this(hashProvider,defaultValue,new VersionedMapStoreConfiguration());
         }
         
+        public static <MAP,KEY,VALUE> List<VersionedMapStore<KEY,VALUE>> createSharedVersionedMapStores(
+                int amount,
+                ContinousHashProvider<? super KEY> hashProvider,
+                VALUE defaultValue,
+                VersionedMapStoreConfiguration config)
+        {
+                List<VersionedMapStore<KEY,VALUE>> result = new ArrayList<>(amount);
+                if(config.sharedNodeCacheInStoreGroups) {
+                        Map<Node<KEY,VALUE>, ImmutableNode<KEY,VALUE>> nodeCache;
+                        if(config.sharedNodeCacheInStore) {
+                                nodeCache = new HashMap<>();
+                        } else {
+                                nodeCache = null;
+                        }
+                        for (int i = 0; i < amount; i++) {
+                                result.add(new VersionedMapStoreImpl<KEY, VALUE>(hashProvider, defaultValue, nodeCache, config));
+                        }
+                } else {
+                        for (int i = 0; i < amount; i++) {
+                                result.add(new VersionedMapStoreImpl<KEY, VALUE>(hashProvider, defaultValue, config));
+                        }
+                }
+                return result;
+        }
+        public static <MAP,KEY,VALUE> List<VersionedMapStore<KEY,VALUE>> createSharedVersionedMapStores(
+                int amount,
+                ContinousHashProvider<? super KEY> hashProvider,
+                VALUE defaultValue)
+        {
+                return createSharedVersionedMapStores(amount,hashProvider,defaultValue,new VersionedMapStoreConfiguration());
+        }
+        
         synchronized Set<Long> getStates() {
                 return states.keySet();
         }