Improve function caching

Author: ngallagher

snap-common/src/main/java/org/snapscript/common/CopyOnWriteSparseArray.java

@@ -0,0 +1,17 @@
+package org.snapscript.common;
+
+public class CopyOnWriteSparseArray<T> extends SparseArray<T> {
+
+   public CopyOnWriteSparseArray(int length) {
+      super(length);
+   }
+
+   public CopyOnWriteSparseArray(int length, int block) {
+      super(length, block);
+   }
+   
+   @Override
+   protected synchronized Object[] segment(int index) {
+      return super.segment(index);
+   }
+}

snap-common/src/test/java/org/snapscript/common/SparseArrayTest.java

@@ -17,6 +17,18 @@ public void testSparseArray(){
       }
    }
 
+   public void testSparseArrayGrowth() {
+      SparseArray sparseArray = new SparseArray(VALUES);
+      for(int i = 0; i <100; i++) {
+         int step = i*100;
+         sparseArray.set(VALUES +step, String.valueOf(i));
+      }
+      for(int i = 0; i <100; i++) {
+         int step = i*100;
+         assertEquals(sparseArray.get(VALUES +step), String.valueOf(i));
+      }
+   }
+   
    private static void compareWithBlock(int block){
       SparseArray sparseArray = new SparseArray(VALUES, block);
       Map hashMap = new HashMap(VALUES);

snap-core/src/main/java/org/snapscript/core/TypeCache.java

@@ -2,25 +2,21 @@
 
 import org.snapscript.common.Cache;
 import org.snapscript.common.CopyOnWriteCache;
+import org.snapscript.common.CopyOnWriteSparseArray;
+import org.snapscript.common.SparseArray;
 
 public class TypeCache<V> {
 
-   private volatile TypeCacheArray<V> array;
-   private volatile Cache<Type, V> cache;
-   private volatile CacheUpdater updater;
+   private final SparseArray<V> array;
+   private final Cache<Type, V> cache;
 
    public TypeCache() {
       this(1000);
    }
 
    public TypeCache(int capacity) {
-      this(capacity, 1000);
-   }
-   
-   public TypeCache(int capacity, int expand) {
-      this.array = new TypeCacheArray<V>(capacity, expand);
-      this.cache = new CopyOnWriteCache<Type, V>();
-      this.updater = new CacheUpdater(capacity);
+      this.array = new CopyOnWriteSparseArray<V>(capacity); // for order > 0
+      this.cache = new CopyOnWriteCache<Type, V>(); // for order = 0
    }
 
    public V take(Type type) {
@@ -29,12 +25,7 @@ public V take(Type type) {
       if(order == 0) {
          return cache.take(type);
       }
-      int length = array.length();
-      
-      if(length > order) {
-         return updater.take(order);
-      }
-      return null;
+      return array.remove(order);
    }
 
    public V fetch(Type type) {
@@ -43,12 +34,7 @@ public V fetch(Type type) {
       if(order == 0) {
          return cache.fetch(type);
       }
-      int length = array.length();
-      
-      if(length > order) {
-         return array.get(order);
-      }
-      return null;
+      return array.get(order);
    }
 
    public boolean contains(Type type) {
@@ -57,12 +43,7 @@ public boolean contains(Type type) {
       if(order == 0) {
          return cache.contains(type);
       }
-      int length = array.length();
-      
-      if(length > order) {
-         return array.get(order) != null;
-      }
-      return false;
+      return array.get(order) != null;
    }
 
    public void cache(Type type, V value) {
@@ -71,41 +52,6 @@ public void cache(Type type, V value) {
       if(order == 0) {
          cache.cache(type, value);
       }
-      int length = array.length();
-      
-      if(length > order) {
-         array.set(order, value);
-      } else {
-         updater.cache(order, value);
-      }
-   }
-
-   private class CacheUpdater {
-      
-      private final int expand;
-      
-      public CacheUpdater(int expand) {
-         this.expand = expand;
-      }
-      
-      public synchronized void cache(int order, V value) {
-         int length = array.length();
-         
-         if(order >= length) {
-            TypeCacheArray<V> copy = array.copy(order + expand);
-
-            copy.set(order, value);
-            array = copy;
-         }
-      }
-      
-      public synchronized V take(int order) {
-         int length = array.length();
-         
-         if(length > order) {
-            return array.set(order, null);
-         }
-         return null;
-      }
+      array.set(order, value);
    }
 }

snap-core/src/main/java/org/snapscript/core/TypeCacheArray.java

@@ -1,11 +1,14 @@
 package org.snapscript.core.bind;
 
+import org.snapscript.core.Type;
+
 public class FunctionKey {      
 
-   private final Object[] types;
-   private final String function;
+   private Type[] types;
+   private String function;
+   private int hash;
 
-   public FunctionKey(String function, Object[] types) {
+   public FunctionKey(String function, Type[] types) {
       this.function = function;
       this.types = types;
    }
@@ -32,10 +35,19 @@ public boolean equals(FunctionKey key) {
 
    @Override
    public int hashCode() {
-      int hash = function.hashCode();
-      
-      hash = hash *31 + types.length;
-      
+      if(hash == 0) {
+         int value = function.hashCode();
+         
+         for(Type type : types) {
+            int order = 1;
+            
+            if(type != null) {
+               order = type.getOrder();
+            }
+            value = value *31 + order;
+         }
+         hash = value;
+      }
       return hash;
    }
 }

snap-core/src/main/java/org/snapscript/core/bind/FunctionKey.java

@@ -1,5 +1,6 @@
 package org.snapscript.core.bind;
 
+import org.snapscript.core.Type;
 import org.snapscript.core.TypeExtractor;
 
 public class FunctionKeyBuilder {
@@ -12,7 +13,7 @@ public FunctionKeyBuilder(TypeExtractor extractor) {
 
    public Object create(String function, Object... list) throws Exception {
       if(list.length > 0) {
-         Object[] types = new Object[list.length];
+         Type[] types = new Type[list.length];
 
          for(int i = 0; i < list.length; i++) {
             Object value = list[i];

snap-core/src/main/java/org/snapscript/core/bind/FunctionKeyBuilder.java

@@ -5,19 +5,20 @@
 
 public class Modifier {
 
-   private final StringToken token;
-   
+   private ModifierType type;
+   private StringToken token;
+
    public Modifier(StringToken token) {
       this.token = token;
    }
 
    public ModifierType getType() {
       String name = token.getValue();
 
-      if(name != null) {
-         return ModifierType.resolveModifier(name);
+      if(type == null) {
+         type =  ModifierType.resolveModifier(name);
       }
-      return null;
-   }
+      return type;
+   } 
 
 }

snap-tree/src/main/java/org/snapscript/tree/Modifier.java

@@ -55,7 +55,6 @@ public Initializer compile(Initializer initializer, Type type) throws Exception
       String name = value.getString();
 
       if(!checker.isConstant()) {
-         throw new InternalStateException("Variable '" + name + "' for '" + type + "; must be constant");
       }
       Accessor accessor = new StaticAccessor(initializer, scope, type, name);
       Property property = new AccessorProperty(name, type, constraint, accessor, ModifierType.STATIC.mask | ModifierType.CONSTANT.mask);