X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FMain%2FMain.java;h=cb8bf768501a1bda095d1cabb30f4c949a924c5f;hb=18ba60849200d7a58a47baa07074b90cdcfb7382;hp=16ae718187bc98b01cd4ef796df4de4b7f2fffb8;hpb=b0a3fca785f72dc0a4bd45004e8d90c907162b6f;p=IRC.git diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java index 16ae7181..cb8bf768 100644 --- a/Robust/src/Main/Main.java +++ b/Robust/src/Main/Main.java @@ -1,140 +1,441 @@ package Main; +import java.io.FileOutputStream; +import java.io.PrintStream; import java.io.Reader; import java.io.BufferedReader; import java.io.FileReader; +import java.io.FileInputStream; +import java.util.Hashtable; +import java.util.Iterator; +import java.util.Set; +import java.util.Vector; + import IR.Tree.ParseNode; import IR.Tree.BuildIR; import IR.Tree.SemanticCheck; +import IR.Flat.BuildCodeMultiCore; import IR.Flat.BuildFlat; import IR.Flat.BuildCode; +import IR.ClassDescriptor; import IR.State; +import IR.TaskDescriptor; import IR.TypeUtil; +import Analysis.Scheduling.MCImplSynthesis; +import Analysis.Scheduling.Schedule; +import Analysis.Scheduling.ScheduleAnalysis; +import Analysis.Scheduling.ScheduleSimulator; import Analysis.TaskStateAnalysis.TaskAnalysis; +import Analysis.TaskStateAnalysis.TaskTagAnalysis; +import Analysis.TaskStateAnalysis.TaskGraph; +import Analysis.CallGraph.CallGraph; +import Analysis.TaskStateAnalysis.FEdge; +import Analysis.TaskStateAnalysis.FlagState; +import Analysis.TaskStateAnalysis.TagAnalysis; +import Analysis.TaskStateAnalysis.GarbageAnalysis; +import Analysis.TaskStateAnalysis.ExecutionGraph; +import Analysis.TaskStateAnalysis.SafetyAnalysis; +import Analysis.Locality.LocalityAnalysis; +import Analysis.Locality.GenerateConversions; +import Analysis.Prefetch.PrefetchAnalysis; +import Analysis.FlatIRGraph.FlatIRGraph; +import Analysis.OwnershipAnalysis.OwnershipAnalysis; +import Analysis.MLP.MLPAnalysis; +import Analysis.Loops.*; +import IR.MethodDescriptor; +import IR.Flat.FlatMethod; +import Interface.*; +import Util.GraphNode; +import Util.GraphNode.DFS; +import Util.GraphNode.SCC; public class Main { - /** Main method for the compiler. */ + /** Main method for the compiler. */ public static void main(String args[]) throws Exception { - String ClassLibraryPrefix="./ClassLibrary/"; - State state=new State(); - - for(int i=0;i -- probability of true branch"); + System.out.println("-printflat -- print out flat representation"); + System.out.println("-instructionfailures -- insert code for instruction level failures"); + System.out.println("-taskstate -- do task state analysis"); + System.out.println("-flatirtasks -- create dot files for flat IR graphs of tasks"); + System.out.println("-flatirusermethods -- create dot files for flat IR graphs of user methods"); + System.out.println("-flatirlibmethods -- create dot files for flat IR graphs of library class methods"); + System.out.println(" note: -flatirusermethods or -flatirlibmethods currently generate all class method flat IR graphs"); + System.out.println("-ownership -- do ownership analysis"); + System.out.println("-ownallocdepth -- set allocation depth for ownership analysis"); + System.out.println("-ownwritedots -- write ownership graphs; can be all results or just final results"); + System.out.println("-ownaliasfile -- write a text file showing all detected aliases in program tasks"); + System.out.println("-optimize -- enable optimizations"); + System.out.println("-optional -- enable optional arguments"); + System.out.println("-abcclose close the array boundary check"); + System.out.println("-scheduling do task scheduling"); + System.out.println("-mlp build mlp code"); + System.out.println("-mlp build mlp code, report progress and interim results"); + System.out.println("-multicore generate multi-core version binary"); + System.out.println("-numcore set the number of cores (should be used together with -multicore), defaultly set as 1"); + System.out.println("-raw generate raw version binary (should be used together with -multicore)"); + System.out.println("-interrupt generate raw version binary with interruption (should be used togethere with -raw)"); + System.out.println("-rawconfig config raw simulator as 4xn (should be used together with -raw)"); + System.out.println("-rawpath print out execute path information for raw version (should be used together with -raw)"); + System.out.println("-useprofile use profiling data for scheduling (should be used together with -raw)"); + System.out.println("-threadsimulate generate multi-thread simulate version binary"); + System.out.println("-rawuseio use standard io to output profiling data (should be used together with -raw and -profile), it only works with single core version"); + System.out.println("-printscheduling -- print out scheduling graphs"); + System.out.println("-printschedulesim -- print out scheduling simulation result graphs"); + System.out.println("-webinterface -- enable web interface"); + System.out.println("-help -- print out help"); + System.exit(0); } else { - readSourceFile(state, ClassLibraryPrefix+"Object.java"); - readSourceFile(state, ClassLibraryPrefix+"TagDescriptor.java"); + sourcefiles.add(args[i]); } + } - if (state.TASK) { - readSourceFile(state, ClassLibraryPrefix+"StartupObject.java"); - readSourceFile(state, ClassLibraryPrefix+"Socket.java"); - readSourceFile(state, ClassLibraryPrefix+"ServerSocket.java"); - } else { - readSourceFile(state, ClassLibraryPrefix+"SocketJava.java"); - readSourceFile(state, ClassLibraryPrefix+"ServerSocketJava.java"); + //add default classpath + if (state.classpath.size()==1) + state.classpath.add(ClassLibraryPrefix); + + BuildIR bir=new BuildIR(state); + TypeUtil tu=new TypeUtil(state, bir); + + + SemanticCheck sc=new SemanticCheck(state,tu); + + for(int i=0;i scheduling = mcImplSynthesis.synthesis(); + + //double timeEndAnalysis = (double) System.nanoTime(); + //double dt = (timeEndAnalysis - timeStartAnalysis)/(Math.pow( 10.0, 9.0 ) ); + //System.err.println("The analysis took" + dt + "sec."); + + // generate multicore codes + if(state.MULTICORE) { + BuildCodeMultiCore bcm=new BuildCodeMultiCore(state, + bf.getMap(), + tu, + sa, + scheduling, + mcImplSynthesis.getCoreNum(), + pa); + bcm.setOwnershipAnalysis(oa); + bcm.buildCode(); + } + scheduling.clear(); + scheduling = null; } - state.addParseNode(p); - if (l.numErrors()!=0) { - System.out.println("Error parsing "+sourcefile); - System.exit(l.numErrors()); + } + } + if(!state.MULTICORE) { + if (state.DSM||state.SINGLETM) { + CallGraph callgraph=new CallGraph(state); + if (state.PREFETCH) { + //speed up prefetch generation using locality analysis results + LocalityAnalysis la=new LocalityAnalysis(state, callgraph, tu); + pa=new PrefetchAnalysis(state, callgraph, tu, la); } + LocalityAnalysis la=new LocalityAnalysis(state, callgraph, tu); + GenerateConversions gc=new GenerateConversions(la, state); + BuildCode bc=new BuildCode(state, bf.getMap(), tu, la, pa); + bc.buildCode(); + } else { + BuildCode bc=new BuildCode(state, bf.getMap(), tu, sa, pa); + bc.buildCode(); + } } + + System.out.println("Lines="+state.lines); + System.exit(0); + } + + public static void loadClass(State state, BuildIR bir, String sourcefile) { + ParseNode pn=readSourceFile(state, sourcefile); + bir.buildtree(pn, null); + } + + /** Reads in a source file and adds the parse tree to the state object. */ + + public static ParseNode readSourceFile(State state, String sourcefile) { + try { + Reader fr= new BufferedReader(new FileReader(sourcefile)); + Lex.Lexer l = new Lex.Lexer(fr); + java_cup.runtime.lr_parser g; + g = new Parse.Parser(l); + ParseNode p=null; + try { + p=(ParseNode) g./*debug_*/parse().value; + } catch (Exception e) { + System.err.println("Error parsing file:"+sourcefile); + e.printStackTrace(); + System.exit(-1); + } + state.addParseNode(p); + if (l.numErrors()!=0) { + System.out.println("Error parsing "+sourcefile); + System.exit(l.numErrors()); + } + state.lines+=l.line_num; + return p; + + } catch (Exception e) { + throw new Error(e); + } + } }