From: jjenista <jjenista>
Date: Thu, 14 May 2009 21:37:42 +0000 (+0000)
Subject: Lots of changes that aren't working yet, so new methods are commented and existing... 
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=5286e56e354ee7449915af1b40f951bb61092cb2;p=IRC.git

Lots of changes that aren't working yet, so new methods are commented and existing code altered for new stuff is checked in.  Won't affect other compiler modes, and checks in stuff to reduce conflicts while getting the sese's working.
---

diff --git a/Robust/src/Analysis/MLP/MLPAnalysis.java b/Robust/src/Analysis/MLP/MLPAnalysis.java
index 9a4dbff1..57bfbb65 100644
--- a/Robust/src/Analysis/MLP/MLPAnalysis.java
+++ b/Robust/src/Analysis/MLP/MLPAnalysis.java
@@ -21,6 +21,8 @@ public class MLPAnalysis {
   private FlatSESEEnterNode rootSESE;
   private FlatSESEExitNode  rootExit;
 
+  private Set<FlatSESEEnterNode> allSESEs;
+
   private Hashtable< FlatNode, Stack<FlatSESEEnterNode> > seseStacks;
   private Hashtable< FlatNode, Set<TempDescriptor>      > livenessRootView;
   private Hashtable< FlatNode, Set<TempDescriptor>      > livenessVirtualReads;
@@ -29,6 +31,18 @@ public class MLPAnalysis {
   private Hashtable< FlatNode, CodePlan                 > codePlans;
 
 
+  // use these methods in BuildCode to have access to analysis results
+  public Set<FlatSESEEnterNode> getAllSESEs() {
+    return allSESEs;
+  }
+
+  public CodePlan getCodePlan( FlatNode fn ) {
+    CodePlan cp = codePlans.get( fn );
+    assert cp != null;
+    return cp;
+  }
+
+
   public MLPAnalysis( State             state,
 		      TypeUtil          tu,
 		      CallGraph         callGraph,
@@ -43,6 +57,8 @@ public class MLPAnalysis {
     this.ownAnalysis = ownAnalysis;
 
     // initialize analysis data structures
+    allSESEs = new HashSet<FlatSESEEnterNode>();
+
     seseStacks           = new Hashtable< FlatNode, Stack<FlatSESEEnterNode> >();
     livenessVirtualReads = new Hashtable< FlatNode, Set<TempDescriptor>      >();
     variableResults      = new Hashtable< FlatNode, VarSrcTokTable           >();
@@ -50,7 +66,6 @@ public class MLPAnalysis {
     codePlans            = new Hashtable< FlatNode, CodePlan                 >();
 
 
-
     // build an implicit root SESE to wrap contents of main method
     rootTree = new SESENode( "root" );
     rootSESE = new FlatSESEEnterNode( rootTree );
@@ -151,7 +166,7 @@ public class MLPAnalysis {
       flatNodesToVisit.remove( fn );
       visited.add( fn );      
 
-      buildForest_nodeActions( fn, seseStack );
+      buildForest_nodeActions( fn, seseStack, fm );
 
       for( int i = 0; i < fn.numNext(); i++ ) {
 	FlatNode nn = fn.getNext( i );
@@ -171,11 +186,16 @@ public class MLPAnalysis {
   }
 
   private void buildForest_nodeActions( FlatNode fn, 							   
-					Stack<FlatSESEEnterNode> seseStack ) {
+					Stack<FlatSESEEnterNode> seseStack,
+					FlatMethod fm ) {
     switch( fn.kind() ) {
 
     case FKind.FlatSESEEnterNode: {
-      FlatSESEEnterNode fsen = (FlatSESEEnterNode) fn;      
+      FlatSESEEnterNode fsen = (FlatSESEEnterNode) fn;
+
+      allSESEs.add( fsen );
+      fsen.setEnclosingFlatMeth( fm );
+
       assert !seseStack.empty();
       seseStack.peek().addChild( fsen );
       fsen.setParent( seseStack.peek() );
diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 7d6f8b85..0d1cbb67 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -22,6 +22,7 @@ import Analysis.CallGraph.CallGraph;
 import Analysis.Prefetch.*;
 import Analysis.Loops.WriteBarrier;
 import Analysis.Locality.TypeAnalysis;
+import Analysis.MLP.MLPAnalysis;
 
 public class BuildCode {
   State state;
@@ -52,23 +53,28 @@ public class BuildCode {
   Hashtable<LocalityBinding, Hashtable<TempDescriptor, TempDescriptor>> backuptable;
   SafetyAnalysis sa;
   PrefetchAnalysis pa;
-  HashSet<FlatSESEEnterNode> setSESEtoGen;
+  MLPAnalysis mlpa;
   boolean nonSESEpass=true;
   WriteBarrier wb;
   DiscoverConflicts dc;
   CallGraph callgraph;
 
   public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, PrefetchAnalysis pa) {
-    this(st, temptovar, typeutil, null, sa, pa);
+    this(st, temptovar, typeutil, null, sa, pa, null);
   }
 
-  public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, PrefetchAnalysis pa) {
-    this(st, temptovar, typeutil, locality, null, pa);
+  public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, PrefetchAnalysis pa, MLPAnalysis mlpa) {
+    this(st, temptovar, typeutil, null, sa, pa, mlpa);
   }
 
-  public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, SafetyAnalysis sa, PrefetchAnalysis pa) {
+  public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, PrefetchAnalysis pa, MLPAnalysis mlpa) {
+    this(st, temptovar, typeutil, locality, null, pa, mlpa);
+  }
+
+  public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, SafetyAnalysis sa, PrefetchAnalysis pa, MLPAnalysis mlpa) {
     this.sa=sa;
     this.pa=pa;
+    this.mlpa=mlpa;
     state=st;
     callgraph=new CallGraph(state);
     if (state.SINGLETM)
@@ -91,8 +97,6 @@ public class BuildCode {
       this.dc=new DiscoverConflicts(locality, st, typeanalysis);
       dc.doAnalysis();
     }
-
-    setSESEtoGen = new HashSet<FlatSESEEnterNode>();
   }
 
   /** The buildCode method outputs C code for all the methods.  The Flat
@@ -184,15 +188,13 @@ public class BuildCode {
     /* Build the actual methods */
     outputMethods(outmethod);
 
+    // Output function prototypes and structures for SESE's and code
     if( state.MLP ) {
       nonSESEpass = false;
-      while( !setSESEtoGen.isEmpty() ) {
-	FlatSESEEnterNode fsen = setSESEtoGen.iterator().next();
-	setSESEtoGen.remove(fsen);
-	generateMethodSESE(fsen, fsen.getEnclosingFlatMeth(), null, outmethod);
+      for(Iterator<FlatSESEEnterNode> seseit=mlpa.getAllSESEs().iterator();seseit.hasNext();) {
+	FlatSESEEnterNode fsen = seseit.next();
+	generateMethodSESE(fsen, null, outstructs, outmethodheader, outmethod);
       }
-    } else {
-      assert setSESEtoGen.isEmpty();
     }
 
     if (state.TASK) {
@@ -1489,35 +1491,156 @@ public class BuildCode {
     output.println("}\n\n");
   }
 
+  /***** Generate code for FlatMethod fm. *****/
+
+  private void generateFlatMethodSESE(FlatMethod fm, 
+                                      ClassDescriptor cn, 
+                                      FlatSESEEnterNode seseEnter, 
+                                      FlatSESEExitNode  seseExit, 
+                                      PrintWriter output
+                                      ) {
+    /*
+    MethodDescriptor md=fm.getMethod();
+    ParamsObject objectparams=(ParamsObject)paramstable.get(md);
+    //generateHeader(fm, lb, md);
+    TempObject objecttemp=(TempObject) tempstable.get(md);
+    */
+
+    /*
+    if (GENERATEPRECISEGC) {
+      output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
+      output.print(objecttemp.numPointers()+",");
+      output.print(paramsprefix);
+      for(int j=0; j<objecttemp.numPointers(); j++)
+	output.print(", NULL");
+      output.println("};");
+    }
+    */
+
+    /*
+    for(int i=0; i<objecttemp.numPrimitives(); i++) {
+      TempDescriptor td=objecttemp.getPrimitive(i);
+      TypeDescriptor type=td.getType();
+      if (type.isNull())
+	output.println("   void * "+td.getSafeSymbol()+";");
+      else if (type.isClass()||type.isArray())
+	output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
+      else
+	output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
+    }
+    */
+
+    /* Check to see if we need to do a GC if this is a
+     * multi-threaded program...*/
+
+    /*
+    if (GENERATEPRECISEGC) {
+      //Don't bother if we aren't in recursive methods...The loops case will catch it
+      if (callgraph.getAllMethods(md).contains(md)) {
+        output.println("if (needtocollect) checkcollect(&"+localsprefix+");");
+      }
+    }
+    */
+
+    //generateCode(seseEnter, getNext(0), fm, null, seseExit, output);
+
+    //output.println("}\n\n");
+  }
 
   protected void generateMethodSESE(FlatSESEEnterNode fsen,
-                                    FlatMethod fm,
                                     LocalityBinding lb,
-                                    PrintWriter output) {
-
-    //output.println( "void _SESE"+fsen.getPrettyIdentifier()+
-    //" {\n" );
-    //generateCode( fsen.getNext(0), fm, lb, fsen.getFlatExit(), output );
-    //output.println( "}\n\n" );
+                                    PrintWriter outputStructs,
+                                    PrintWriter outputMethHead,
+                                    PrintWriter outputMethods
+                                    ) {
 
     /*
-       output.println("struct sese"+faen.getPrettyIdentifier()+"in {");
-       Iterator<TempDescriptor> itr = faen.getInVarSet().iterator();
-       while( itr.hasNext() ) {
-       TempDescriptor td = itr.next();
-       output.println("  "+td+";");
-       }
-       output.println("}");
+    FlatMethod       fm = fsen.getEnclosingFlatMeth();
+    MethodDescriptor md = fm.getMethod();
+    ClassDescriptor  cn = md.getClassDesc();
+    
+    
+    //Creates bogus method descriptor to index into tables
+    Modifiers bogusmod=new Modifiers();
+    MethodDescriptor bogusmd=new MethodDescriptor(bogusmod, new TypeDescriptor(TypeDescriptor.VOID), fsen.getIdentifier());
+    FlatMethod bogusfm=new FlatMethod(bogusmd, null);
+    
+    //Build paramsobj for bogus method descriptor
+    ParamsObject objectparams=new ParamsObject(bogusmd, tag++);
+    paramstable.put(bogusmd, objectparams);
+    
+    for(int i=0; i<fsen.numParameters(); i++) {
+      TempDescriptor temp=fsen.getParameter(i);
+      TypeDescriptor type=temp.getType();
+      if (type.isPtr()&&GENERATEPRECISEGC)
+	objectparams.addPtr(temp);
+      else
+	objectparams.addPrim(temp);
+    }
+    
+    //Build normal temp object for bogus method descriptor
+    
+    TempObject objecttemps=new TempObject(objectparams,bogusmd,tag++);
+    tempstable.put(bogusmd, objecttemps);
+    
+    for(Iterator nodeit=fsen.getNodeSet().iterator(); nodeit.hasNext();) {
+      FlatNode fn=(FlatNode)nodeit.next();
+      TempDescriptor[] writes=fn.writesTemps();
+      for(int i=0; i<writes.length; i++) {
+	TempDescriptor temp=writes[i];
+	TypeDescriptor type=temp.getType();
+	if (type.isPtr()&&GENERATEPRECISEGC)
+	  objecttemps.addPtr(temp);
+	else
+	  objecttemps.addPrim(temp);
+      }
+    }
+    
+    //Generate code for parameters structure
+
+    generateMethodParam(cn, bogusmd, null, outputStructs); 
+
+    //Generate code for locals structure
+    outputStructs.println("struct "+cn.getSafeSymbol()+bogusmd.getSafeSymbol()+"_"+bogusmd.getSafeMethodDescriptor()+"_locals {");
+    outputStructs.println("  INTPTR size;");
+    outputStructs.println("  void * next;");
+    for(int i=0; i<objecttemps.numPointers(); i++) {
+      TempDescriptor temp=objecttemps.getPointer(i);
+      if (temp.getType().isNull())
+        outputStructs.println("  void * "+temp.getSafeSymbol()+";");
+      else
+        outputStructs.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
+    }
+    outputStructs.println("};\n");
+    
+    //Ready to build code at this point
 
-       output.println("struct sese"+faen.getPrettyIdentifier()+"out {");
-       itr = faen.getOutVarSet().iterator();
-       while( itr.hasNext() ) {
-       TempDescriptor td = itr.next();
-       output.println("  "+td+";");
-       }
-       output.println("}");
-     */
+    headersout.print("void ");
 
+    // Next the method name
+    headersout.print(cn.getSafeSymbol()+bogusmd.getSafeSymbol()+"_"+bogusmd.getSafeMethodDescriptor()+"(");
+
+    boolean printcomma=false;
+    if (GENERATEPRECISEGC) {
+      headersout.print("struct "+cn.getSafeSymbol()+bogusmd.getSafeSymbol()+"_"+bogusmd.getSafeMethodDescriptor()+"_params * "+paramsprefix);
+      printcomma=true;
+    }
+
+    //  Output parameter list
+    for(int i=0; i<objectparams.numPrimitives(); i++) {
+      TempDescriptor temp=objectparams.getPrimitive(i);
+      if (printcomma)
+	headersout.print(", ");
+      printcomma=true;
+      if (temp.getType().isClass()||temp.getType().isArray())
+	headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
+      else
+	headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
+    }
+    headersout.println(");\n");
+
+    generateFlatMethodSESE(bogusfm, cn, fsen, fsen.getFlatExit(), output?????????);
+    */
   }
 
 
@@ -1565,10 +1688,6 @@ public class BuildCode {
 	FlatNode nextnode;
 	if (state.MLP && current_node.kind()==FKind.FlatSESEEnterNode) {
 	  FlatSESEEnterNode fsen = (FlatSESEEnterNode)current_node;
-	  if( nonSESEpass ) {
-	    setSESEtoGen.add(fsen);
-	    fsen.setEnclosingFlatMeth(fm);
-	  }
 	  nextnode=fsen.getFlatExit().getNext(0);
 	} else {
 	  output.print("   ");
@@ -1635,6 +1754,7 @@ public class BuildCode {
     MethodDescriptor md=fm.getMethod();
     TaskDescriptor task=fm.getTask();
     TempObject objecttemps=(TempObject) tempstable.get(lb!=null ? lb : md!=null ? md : task);
+
     if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
       //System.out.println("generateTemp returns " + td.getSafeSymbol());
       return td.getSafeSymbol();
@@ -1647,6 +1767,7 @@ public class BuildCode {
     if (objecttemps.isParamPtr(td)) {
       return paramsprefix+"->"+td.getSafeSymbol();
     }
+
     throw new Error();
   }
 
diff --git a/Robust/src/IR/Flat/FlatSESEEnterNode.java b/Robust/src/IR/Flat/FlatSESEEnterNode.java
index 11da4cb8..4d8968d4 100644
--- a/Robust/src/IR/Flat/FlatSESEEnterNode.java
+++ b/Robust/src/IR/Flat/FlatSESEEnterNode.java
@@ -64,6 +64,49 @@ public class FlatSESEEnterNode extends FlatNode {
     return inVars;
   }
 
+  Vector<TempDescriptor> vecinVars;
+  void buildvarVec() {
+    HashSet<TempDescriptor> paramset=new HashSet<TempDescriptor>();
+    paramset.addAll(inVars);
+    paramset.addAll(outVars);
+    vecinVars=new Vector<TempDescriptor>();
+    vecinVars.addAll(paramset);
+  }
+
+  public TempDescriptor getParameter(int i) {
+    if (vecinVars==null) {
+      buildvarVec();
+    }
+    return vecinVars.get(i);
+  }
+
+  public int numParameters() {
+    if (vecinVars==null) {
+      buildvarVec();
+    }
+    return vecinVars.size();
+  }
+
+  public Set<FlatNode> getNodeSet() {
+    HashSet<FlatNode> tovisit=new HashSet<FlatNode>();
+    HashSet<FlatNode> visited=new HashSet<FlatNode>();
+    tovisit.add(this);
+    while(!tovisit.isEmpty()) {
+      FlatNode fn=tovisit.iterator().next();
+      tovisit.remove(fn);
+      visited.add(fn);
+      
+      if (fn!=exit) {
+	for(int i=0; i<fn.numNext(); i++) {
+	  FlatNode nn=fn.getNext(i);
+	  if (!visited.contains(nn))
+	    tovisit.add(nn);
+	}
+      }
+    }
+    return visited;
+  }
+
   public Set<TempDescriptor> getOutVarSet() {
     return outVars;
   }
diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java
index ec102337..45625edf 100644
--- a/Robust/src/Main/Main.java
+++ b/Robust/src/Main/Main.java
@@ -248,6 +248,7 @@ public class Main {
     bf.buildFlat();
     SafetyAnalysis sa=null;
     PrefetchAnalysis pa=null;
+    MLPAnalysis mlpa=null;
 
     if (state.OPTIMIZE) {
       CallGraph callgraph=new CallGraph(state);
@@ -303,10 +304,10 @@ public class Main {
                                                    state.OWNERSHIPWRITEDOTS,
                                                    state.OWNERSHIPWRITEALL,
                                                    state.OWNERSHIPALIASFILE);
-      MLPAnalysis mlpa = new MLPAnalysis(state,
-					 tu,
-					 callGraph,
-					 oa);
+      mlpa = new MLPAnalysis(state,
+                             tu,
+                             callGraph,
+                             oa);
     }    
 
     if (state.TAGSTATE) {
@@ -394,10 +395,10 @@ public class Main {
 	}
 	LocalityAnalysis la=new LocalityAnalysis(state, callgraph, tu);
 	GenerateConversions gc=new GenerateConversions(la, state);
-	BuildCode bc=new BuildCode(state, bf.getMap(), tu, la, pa);
+	BuildCode bc=new BuildCode(state, bf.getMap(), tu, la, pa, mlpa);
 	bc.buildCode();
       } else {
-	BuildCode bc=new BuildCode(state, bf.getMap(), tu, sa, pa);
+	BuildCode bc=new BuildCode(state, bf.getMap(), tu, sa, pa, mlpa);
 	bc.buildCode();
       }
     }
diff --git a/Robust/src/Tests/mlp/tinyTest/makefile b/Robust/src/Tests/mlp/tinyTest/makefile
index ad9d6ba8..897d72e8 100644
--- a/Robust/src/Tests/mlp/tinyTest/makefile
+++ b/Robust/src/Tests/mlp/tinyTest/makefile
@@ -3,8 +3,7 @@ PROGRAM=test
 SOURCE_FILES=$(PROGRAM).java
 
 BUILDSCRIPT=~/research/Robust/src/buildscript
-BSFLAGS= -mlpdebug -justanalyze -mainclass Test -ownership -ownallocdepth 1 -ownwritedots final -enable-assertions -flatirusermethods -ownaliasfile aliases.txt #-justanalyze -recover 
-#BSFLAGS= -mainclass Test -ownership -ownallocdepth 1 -ownwritedots final -enable-assertions -flatirusermethods -ownaliasfile aliases.txt #-justanalyze -recover 
+BSFLAGS= -mlpdebug  -mainclass Test -ownership -ownallocdepth 1 -ownwritedots final -enable-assertions -flatirusermethods -ownaliasfile aliases.txt
 
 
 all: $(PROGRAM).bin
diff --git a/Robust/src/Tests/mlp/tinyTest/test.java b/Robust/src/Tests/mlp/tinyTest/test.java
index 2c38702c..c55d0b18 100644
--- a/Robust/src/Tests/mlp/tinyTest/test.java
+++ b/Robust/src/Tests/mlp/tinyTest/test.java
@@ -40,5 +40,12 @@ public class Test {
     y = y + 1;
     x = x + 1;
     z = z + 1;
+
+    //Integer i;
+    //afunc( i );
+  }
+
+  public static void afunc( Integer i ) {
+    i = null;
   }
 }