Changeset 879

Timestamp:

10/04/07 16:55:44 (2 years ago)

Author:

dr2chase

Message:

Fixes to overloading and instantiation deadlocks

Location:

trunk/ProjectFortress

Files:

• quickzip (added)
• src/com/sun/fortress/interpreter/evaluator/EvalType.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/evaluator/Init.java (modified) (2 diffs)
• src/com/sun/fortress/interpreter/evaluator/InstantiationLock.java (added)
• src/com/sun/fortress/interpreter/evaluator/OverloadJUTest.java (modified) (2 diffs)
• src/com/sun/fortress/interpreter/evaluator/ScoutVisitor.java (added)
• src/com/sun/fortress/interpreter/evaluator/types/FTraitOrObjectOrGeneric.java (modified) (2 diffs)
• src/com/sun/fortress/interpreter/evaluator/types/FType.java (modified) (4 diffs)
• src/com/sun/fortress/interpreter/evaluator/types/FTypeGeneric.java (modified) (3 diffs)
• src/com/sun/fortress/interpreter/evaluator/types/FTypeOpr.java (modified) (3 diffs)
• src/com/sun/fortress/interpreter/evaluator/types/FTypeTuple.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/evaluator/values/GenericConstructor.java (modified) (3 diffs)
• src/com/sun/fortress/interpreter/evaluator/values/Overload.java (modified) (3 diffs)
• src/com/sun/fortress/interpreter/evaluator/values/OverloadedFunction.java (modified) (12 diffs)
• src/com/sun/fortress/useful/DebugletPrintStream.java (added)
• src/com/sun/fortress/useful/LazyMemo1PC.java (added)
• src/com/sun/fortress/useful/LazyMemo1PCL.java (added)
• src/com/sun/fortress/useful/Memo1PCL.java (added)
• test (modified) (1 diff)
• testForDebug (added)

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/EvalType.java

@@ -313 +313 @@
 
     public FType forOprArg(OprArg b) {
-        return new FTypeOpr(NodeUtil.nameString(b.getName()));
+        return FTypeOpr.make(NodeUtil.nameString(b.getName()));
     }
 

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/Init.java

@@ -30 +30 @@
 import com.sun.fortress.interpreter.evaluator.types.FTypeLong;
 import com.sun.fortress.interpreter.evaluator.types.FTypeNumber;
+import com.sun.fortress.interpreter.evaluator.types.FTypeOpr;
 import com.sun.fortress.interpreter.evaluator.types.FTypeOverloadedArrow;
 import com.sun.fortress.interpreter.evaluator.types.FTypeRange;
@@ -51 +52 @@
         FTypeArrow.reset();
         FTypeTuple.reset();
+        FTypeOpr.reset();
         FTypeRest.reset();
         FTypeOverloadedArrow.reset();

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/OverloadJUTest.java

@@ -43 +43 @@
         super("OverloadJUTest");
     }
-    private Overload simple_overload(List<FType> types) {
-        return new Overload(new Dummy_fcn(types));
+    private Overload simple_overload(List<FType> types, OverloadedFunction olf) {
+        return new Overload(new Dummy_fcn(types), olf);
     }
 
@@ -77 +77 @@
               NodeFactory.makeIdName("dummyOverloadName"), BetterEnv.primitive("Test overload dispatch"));
         for(List<FType> cl: clauses) {
-            fcn.addOverload(simple_overload(cl));
+            fcn.addOverload(simple_overload(cl, fcn));
         }
         fcn.finishInitializing();

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/types/FTraitOrObjectOrGeneric.java

@@ -88 +88 @@
                     // if (x.getStaticParams().isPresent()) {
                     if (x instanceof FTypeGeneric) {
-                        cl = new OverloadedFunction(fndod.getName(), topLevel);
+                        
+                           cl = new OverloadedFunction(fndod.getName(), topLevel);
+                           topLevel.putValueNoShadowFn(fndodname, cl);
+                        
                     } else {
                         // Note that the instantiation of a generic
@@ -94 +97 @@
                         // here too
                         cl = new FunctionalMethod(topLevel, fndod, spi, x);
+                        topLevel.putValueNoShadowFn(fndodname, cl);
                     }
 
                     // TODO test and other modifiers
 
-                    topLevel.putValueNoShadowFn(fndodname, cl);
+                    
                 }
             }

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/types/FType.java

@@ -38 +38 @@
 import com.sun.fortress.useful.EmptyLatticeIntervalError;
 import com.sun.fortress.useful.HasAt;
+import com.sun.fortress.useful.ListComparer;
 import com.sun.fortress.useful.MagicNumbers;
 import com.sun.fortress.useful.Pair;
@@ -51 +52 @@
     protected static final boolean DUMP_UNIFY = false;
 
-    static Comparator<FType> comparator = new Comparator<FType>() {
+    static public Comparator<FType> comparator = new Comparator<FType>() {
 
         public int compare(FType arg0, FType arg1) {
@@ -59 +60 @@
     };
 
+    static public ListComparer<FType> listComparer = new ListComparer<FType>();
+    
     // static Random random = new Random(0xd06f00d);
 
@@ -248 +251 @@
         }
 
-        for (FType t : getTransitiveExtends()) {
+        List<FType> extendsThis = getTransitiveExtends();
+        for (FType t : extendsThis) {
             BASet t_excludes = t.excludes;
-            for (FType o : other.getTransitiveExtends()) {
+            if (t_excludes.isEmpty())
+                continue;
+            List<FType> extendsOther = other.getTransitiveExtends();
+            for (FType o : extendsOther) {
                 if ( !(t == this && o == other) && t_excludes.contains(o)) {
                     // Short-circuit any future queries

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/types/FTypeGeneric.java

@@ -18 +18 @@
 package com.sun.fortress.interpreter.evaluator.types;
 
+import static com.sun.fortress.interpreter.evaluator.InterpreterBug.bug;
+import static com.sun.fortress.interpreter.evaluator.ProgramError.error;
+import static com.sun.fortress.interpreter.evaluator.ProgramError.errorMsg;
+
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 import com.sun.fortress.interpreter.env.BetterEnv;
 import com.sun.fortress.interpreter.evaluator.BuildEnvironments;
 import com.sun.fortress.interpreter.evaluator.EvalType;
+import com.sun.fortress.interpreter.evaluator.InstantiationLock;
 import com.sun.fortress.interpreter.rewrite.OprInstantiater;
 import com.sun.fortress.nodes.AbsDeclOrDecl;
@@ -32 +36 @@
 import com.sun.fortress.nodes.ObjectDecl;
 import com.sun.fortress.nodes.OperatorParam;
-import com.sun.fortress.nodes.TraitObjectAbsDeclOrDecl;
-import com.sun.fortress.nodes._RewriteObjectExpr;
 import com.sun.fortress.nodes.StaticArg;
 import com.sun.fortress.nodes.StaticParam;
 import com.sun.fortress.nodes.TraitAbsDeclOrDecl;
+import com.sun.fortress.nodes.TraitObjectAbsDeclOrDecl;
+import com.sun.fortress.nodes._RewriteObjectExpr;
 import com.sun.fortress.nodes_util.NodeUtil;
 import com.sun.fortress.useful.Factory1P;
 import com.sun.fortress.useful.HasAt;
 import com.sun.fortress.useful.LazyFactory1P;
-import com.sun.fortress.useful.LazyMemo1P;
+import com.sun.fortress.useful.LazyMemo1PCL;
 import com.sun.fortress.useful.Useful;
-
-import static com.sun.fortress.interpreter.evaluator.ProgramError.error;
-import static com.sun.fortress.interpreter.evaluator.ProgramError.errorMsg;
-import static com.sun.fortress.interpreter.evaluator.InterpreterBug.bug;
 
 public class FTypeGeneric extends FTraitOrObjectOrGeneric implements Factory1P<List<FType>, FTraitOrObject, HasAt> {
@@ -231 +231 @@
 
 
-    LazyMemo1P<List<FType>, FTraitOrObject, HasAt> memo =
-        new LazyMemo1P<List<FType>, FTraitOrObject, HasAt>(
-            new Factory());
+    LazyMemo1PCL<List<FType>, FTraitOrObject, HasAt> memo =
+        new LazyMemo1PCL<List<FType>, FTraitOrObject, HasAt>(
+            new Factory(), FType.listComparer, InstantiationLock.L);
 
     public FTraitOrObject make(List<FType> l, HasAt within) {

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/types/FTypeOpr.java

@@ -18 +18 @@
 package com.sun.fortress.interpreter.evaluator.types;
 
+import java.util.List;
 import java.util.Set;
 import com.sun.fortress.interpreter.env.BetterEnv;
@@ -23 +24 @@
 import com.sun.fortress.nodes.Type;
 import com.sun.fortress.useful.BoundingMap;
+import com.sun.fortress.useful.Factory1;
+import com.sun.fortress.useful.Memo1C;
+import com.sun.fortress.useful.StringComparer;
 
 import static com.sun.fortress.interpreter.evaluator.ProgramError.errorMsg;
@@ -28 +32 @@
 
 public class FTypeOpr extends FType {
-    public FTypeOpr(String s) {
+    private FTypeOpr(String s) {
         super(s);
     }
 
+    static Memo1C<String, FType> memo = null;
+
+    private static class Factory implements Factory1<String, FType> {
+        public FType make(String part1) {
+            return new FTypeOpr(part1);
+        }
+    }
+    
+    public static void reset() {
+        memo = new Memo1C<String, FType>( new Factory(), StringComparer.V);
+    }
+    
+    static public FType make(String s) {
+        return memo.make(s);
+    }
+    
     /*
      * @see com.sun.fortress.interpreter.evaluator.types.FType#unifyNonVar(java.util.Set, com.sun.fortress.interpreter.useful.ABoundingMap,

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/types/FTypeTuple.java

@@ -46 +46 @@
 public class FTypeTuple extends FType {
 
-    static ListComparer<FType> listComparer = new ListComparer<FType>();
     List<FType> l;
 

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/values/GenericConstructor.java

@@ -25 +25 @@
 import com.sun.fortress.interpreter.evaluator.Environment;
 import com.sun.fortress.interpreter.evaluator.EvalType;
+import com.sun.fortress.interpreter.evaluator.InstantiationLock;
 import com.sun.fortress.interpreter.evaluator.types.FType;
 import com.sun.fortress.interpreter.evaluator.types.FTypeGeneric;
@@ -36 +37 @@
 import com.sun.fortress.useful.HasAt;
 import com.sun.fortress.useful.Memo1P;
+import com.sun.fortress.useful.Memo1PCL;
 import com.sun.fortress.useful.Useful;
 
@@ -64 +66 @@
     }
 
-     Memo1P<List<FType>, Constructor, HasAt> memo =
-         new Memo1P<List<FType>, Constructor, HasAt>(new Factory());
+     Memo1PCL<List<FType>, Constructor, HasAt> memo =
+         new Memo1PCL<List<FType>, Constructor, HasAt>(new Factory(), FType.listComparer, InstantiationLock.L);
 
      public Constructor make(List<FType> l, HasAt within) {

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/values/Overload.java

@@ -22 +22 @@
 import com.sun.fortress.interpreter.evaluator.InterpreterBug;
 import com.sun.fortress.interpreter.evaluator.types.FType;
+import com.sun.fortress.useful.DebugletPrintStream;
 import com.sun.fortress.useful.HasAt;
 
@@ -42 +43 @@
     }
 
-    public Overload(SingleFcn fn) {
+    public Overload(SingleFcn fn, OverloadedFunction olf) {
         this.fn = fn;
     }
@@ -72 +73 @@
 
     private SingleFcn fn;
+    
+    DebugletPrintStream ps;
 
     /* (non-Javadoc)

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/values/OverloadedFunction.java

@@ -18 +18 @@
 package com.sun.fortress.interpreter.evaluator.values;
 
+import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.List;
@@ -26 +27 @@
 import com.sun.fortress.interpreter.evaluator.EvaluatorBase;
 import com.sun.fortress.interpreter.evaluator.FortressError;
+import com.sun.fortress.interpreter.evaluator.InstantiationLock;
 import com.sun.fortress.interpreter.evaluator.ProgramError;
 import com.sun.fortress.interpreter.evaluator.types.FType;
@@ -39 +41 @@
 import com.sun.fortress.nodes.FnRef;
 import com.sun.fortress.useful.BATreeEC;
+import com.sun.fortress.useful.DebugletPrintStream;
 import com.sun.fortress.useful.Factory1P;
 import com.sun.fortress.useful.HasAt;
@@ -52 +55 @@
     implements Factory1P<List<FType>, Fcn, HasAt>{
 
+    private final boolean debug = false;
+    /**
+     * Disables ALL consistency checking of overloaded functions.
+     */
+    private final boolean noCheck = false;
+    
     protected volatile List<Overload> overloads = new ArrayList<Overload>();
     private List<Overload> pendingOverloads = new ArrayList<Overload>();
-    protected volatile boolean finishedFirst = false;
-    protected volatile boolean finishedSecond = false;
+    protected volatile boolean finishedFirst = true; // an empty overload is consistent
+    protected volatile boolean finishedSecond = true;
     protected SimpleName fnName;
     
-    private Thread currentUpdater;
-
     static final boolean DUMP_EXCLUSION = false;
 
@@ -124 +131 @@
             ol = pendingOverloads.get(i);
             SingleFcn sfcn = ol.getFn();
+            
+            String ps = ol.ps != null ? String.valueOf(ol.ps) + " " : "";
+            
             if (sfcn instanceof Closure)  {
                 Closure cl = (Closure) sfcn;
                 if (! cl.getFinished())
                     cl.finishInitializing();
+                
+                if (debug) {
+                    System.err.println("Overload " + ps  + cl);
+                }
 
             } else if (sfcn instanceof Dummy_fcn) {
-                // Primitives are all ready
+                if (debug)
+                    System.err.println("Overload primitive " + ps  + sfcn);
 
             } else if (sfcn instanceof FGenericFunction) {
-                // no finishInitializing for these guys, yet
+                if (debug)
+                    System.err.println("Overload generic " + ps  + sfcn);
 
             } else {
@@ -139 +155 @@
                              sfcn));
              }
+            
+            if (ol.ps != null)
+                ol.ps.close();
         }
         finishedFirst = true;
@@ -163 +182 @@
             ftalist.add(new_overloads.get(i).getFn().type());
 
+            if (!noCheck) {
+            
             for (int j = i-1; j >= 0 ; j--) {
                 Overload o1 = new_overloads.get(i);
@@ -320 +341 @@
                 }
             }
+            }
         }
         FType ftoa = FTypeOverloadedArrow.make(ftalist);
@@ -405 +427 @@
 //        if (finishedFirst && !fn.getFinished())
 //            throw new IllegalStateException("Any functions added after finishedFirst must have types assigned.");
-        addOverload(new Overload(fn));
+        addOverload(new Overload(fn, this));
     }
 
@@ -427 +449 @@
      * @param overload
      */
-    public synchronized void addOverload(Overload overload) {
+    public void addOverload(Overload overload) {
 //        if (finishedSecond)
 //            throw new IllegalStateException("Cannot add overloads after overloaded function is complete");
         
-        Thread me = Thread.currentThread();
+//        Thread me = Thread.currentThread();
+//        
+//        if (currentUpdater == null) {
+//            currentUpdater = me;
+//        }
+//        
+//        while (currentUpdater != me) {
+//            try {
+//                wait();
+//            } catch (InterruptedException e) {
+//                // TODO Auto-generated catch block
+//                e.printStackTrace();
+//            }
+//            if (currentUpdater == null)
+//                currentUpdater = me;
+//        }
+//        
         
-        if (currentUpdater == null) {
-            currentUpdater = me;
+        if (!finishedSecond) {
+            pendingOverloads.add(overload);
+            // InstantiationLock.lastOverload = this;
+            // InstantiationLock.lastOverloadThrowable = Useful.backtrace(0, 1000);
+        } else {
+            // InstantiationLock.L.lock();
+            if (debug)
+                System.err.println("Lock " + fnName.stringName());
+            finishedFirst = false;
+            finishedSecond = false;
+            pendingOverloads.add(overload);
+            // InstantiationLock.lastOverload = this;
+            // InstantiationLock.lastOverloadThrowable = Useful.backtrace(0, 1000);
         }
         
-        while (currentUpdater != me) {
-            try {
-                wait();
-            } catch (InterruptedException e) {
-                // TODO Auto-generated catch block
-                e.printStackTrace();
-            }
-            if (currentUpdater == null)
-                currentUpdater = me;
-        }
-        
-        finishedFirst = false;
-        finishedSecond = false;
-        pendingOverloads.add(overload);
+        if (debug) {
+            DebugletPrintStream ps = DebugletPrintStream.make("OVERLOADS");
+            overload.ps = ps;
+            System.err.println("add " + ps + " " + overload);
+            ps.backtrace().flush();
+        }
         
     }
@@ -481 +522 @@
      */
     public int bestMatchIndex(List<FValue> args, HasAt loc, BetterEnv envForInference) throws Error {
-        if (!finishedSecond) {
-            synchronized(this) {
-                if (!finishedSecond &&
-                        (currentUpdater == Thread.currentThread() ||
-                         currentUpdater == null))
-                    bug(loc,"Cannot call before 'setFinished()'");
-            }
-        }
+      
+        if (!finishedSecond && InstantiationLock.L.isHeldByCurrentThread())
+            bug(loc, "Cannot call before 'setFinished()'");
            
         int best = -1;
@@ -567 +603 @@
      * very exciting overload consistency test.
      */
-    public synchronized void bless() {
+    public void bless() {
+        if (finishedSecond)
+            return;
         this.overloads = pendingOverloads;
         this.pendingOverloads = new ArrayList<Overload>();
         finishedSecond = true;
         finishedFirst = true;
-        notifyAll();
-        currentUpdater = null;
+        if (debug)
+            System.err.println("Unlock " + fnName.stringName());
+        // InstantiationLock.L.unlock();
     }
 

trunk/ProjectFortress/test

@@ -24 +24 @@
 fi
 
-java -cp "$CP" -Xmx320m -Xms192m \
+
+
+java -cp "$CP" -Xmx512m -Xms256m \
 junit.swingui.TestRunner \
 com.sun.fortress.interpreter.drivers.SystemJUTests >& test.log