X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FMain%2FMain.java;h=e218d333aa46ea1060175e2276071f4dc2c8ff54;hb=4cb63e913202459da4fe9d01feb7c02f1b98dd6f;hp=6e7f80fc36e90a1007d60ff23b5e6ea9f555200d;hpb=4b188fd7715dc5e14068f9e82f311f62a116171f;p=IRC.git diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java index 6e7f80fc..e218d333 100644 --- a/Robust/src/Main/Main.java +++ b/Robust/src/Main/Main.java @@ -1,24 +1,45 @@ package Main; +import java.io.FileOutputStream; +import java.io.InputStream; +import java.io.PrintStream; import java.io.Reader; import java.io.BufferedReader; import java.io.FileReader; +import java.io.FileInputStream; +import java.util.Iterator; +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.Schedule; +import Analysis.Scheduling.ScheduleAnalysis; +import Analysis.Scheduling.ScheduleEdge; +import Analysis.Scheduling.ScheduleNode; +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 Interface.*; public class Main { @@ -28,17 +49,31 @@ public class Main { 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("-optional -- enable optional arguments"); System.out.println("-webinterface -- enable web interface"); System.out.println("-help -- print out help"); @@ -87,12 +152,20 @@ public class Main { readSourceFile(state, ClassLibraryPrefix+"HashEntry.java"); readSourceFile(state, ClassLibraryPrefix+"Integer.java"); readSourceFile(state, ClassLibraryPrefix+"StringBuffer.java"); + //if(!state.RAW) { readSourceFile(state, ClassLibraryPrefix+"FileInputStream.java"); + readSourceFile(state, ClassLibraryPrefix+"InputStream.java"); + readSourceFile(state, ClassLibraryPrefix+"OutputStream.java"); readSourceFile(state, ClassLibraryPrefix+"FileOutputStream.java"); readSourceFile(state, ClassLibraryPrefix+"File.java"); readSourceFile(state, ClassLibraryPrefix+"InetAddress.java"); - - + readSourceFile(state, ClassLibraryPrefix+"SocketInputStream.java"); + readSourceFile(state, ClassLibraryPrefix+"SocketOutputStream.java"); + //} + readSourceFile(state, ClassLibraryPrefix+"Math.java"); + readSourceFile(state, ClassLibraryPrefix+"gnu/Random.java"); + readSourceFile(state, ClassLibraryPrefix+"Vector.java"); + readSourceFile(state, ClassLibraryPrefix+"Enumeration.java"); if (state.TASK) { readSourceFile(state, ClassLibraryPrefix+"Object.java"); @@ -100,6 +173,7 @@ public class Main { } else if (state.DSM) { readSourceFile(state, ClassLibraryPrefix+"ThreadDSM.java"); readSourceFile(state, ClassLibraryPrefix+"ObjectJavaDSM.java"); + readSourceFile(state, ClassLibraryPrefix+"Barrier.java"); } else { if (state.THREAD) { readSourceFile(state, ClassLibraryPrefix+"Thread.java"); @@ -128,6 +202,14 @@ public class Main { BuildFlat bf=new BuildFlat(state,tu); bf.buildFlat(); + SafetyAnalysis sa=null; + PrefetchAnalysis pa=null; + + if (state.TAGSTATE) { + CallGraph callgraph=new CallGraph(state); + TagAnalysis taganalysis=new TagAnalysis(state, callgraph); + TaskTagAnalysis tta=new TaskTagAnalysis(state, taganalysis); + } if (state.TASKSTATE) { CallGraph callgraph=new CallGraph(state); @@ -140,8 +222,8 @@ public class Main { if (state.OPTIONAL) { ExecutionGraph et=new ExecutionGraph(state, ta); et.createExecutionGraph(); - SafetyAnalysis sa = new SafetyAnalysis(et.getExecutionGraph(), state, ta); - sa.buildPath(); + sa = new SafetyAnalysis(et.getExecutionGraph(), state, ta); + sa.doAnalysis(); state.storeAnalysisResult(sa.getResult()); state.storeOptionalTaskDescriptors(sa.getOptionalTaskDescriptors()); } @@ -153,19 +235,232 @@ public class Main { serve.run(); } + if (state.SCHEDULING) { + // Save the current standard input, output, and error streams + // for later restoration. + PrintStream origOut = System.out; + + // Create a new output stream for the standard output. + PrintStream stdout = null; + try { + stdout = new PrintStream (new FileOutputStream("SimulatorResult.out")); + } catch (Exception e) { + // Sigh. Couldn't open the file. + System.out.println ("Redirect: Unable to open output file!"); + System.exit (1); + } + + // Print stuff to the original output and error streams. + // On most systems all of this will end up on your console when you + // run this application. + //origOut.println ("\nRedirect: Round #1"); + //System.out.println ("Test output via 'System.out'."); + //origOut.println ("Test output via 'origOut' reference."); + + // Set the System out and err streams to use our replacements. + System.setOut(stdout); + + // Print stuff to the original output and error streams. + // The stuff printed through the 'origOut' and 'origErr' references + // should go to the console on most systems while the messages + // printed through the 'System.out' and 'System.err' will end up in + // the files we created for them. + //origOut.println ("\nRedirect: Round #2"); + //System.out.println ("Test output via 'SimulatorResult.out'."); + //origOut.println ("Test output via 'origOut' reference."); + + // for test + // Randomly set the newRate and probability of FEdges + java.util.Random r=new java.util.Random(); + int tint = 0; + for(Iterator it_classes=state.getClassSymbolTable().getDescriptorsIterator();it_classes.hasNext();) { + ClassDescriptor cd=(ClassDescriptor) it_classes.next(); + if(cd.hasFlags()){ + Vector rootnodes=ta.getRootNodes(cd); + if(rootnodes!=null) + for(Iterator it_rootnodes=rootnodes.iterator();it_rootnodes.hasNext();){ + FlagState root=(FlagState)it_rootnodes.next(); + Vector allocatingTasks = root.getAllocatingTasks(); + if(allocatingTasks != null) { + for(int k = 0; k < allocatingTasks.size(); k++) { + TaskDescriptor td = (TaskDescriptor)allocatingTasks.elementAt(k); + Vector fev = (Vector)ta.getFEdgesFromTD(td); + int numEdges = fev.size(); + int total = 100; + for(int j = 0; j < numEdges; j++) { + FEdge pfe = fev.elementAt(j); + if(numEdges - j == 1) { + pfe.setProbability(total); + } else { + if((total != 0) && (total != 1)){ + do { + tint = r.nextInt()%total; + } while(tint <= 0); + } + pfe.setProbability(tint); + total -= tint; + } + /*do { + tint = r.nextInt()%10; + } while(tint <= 0);*/ + //int newRate = tint; + //int newRate = (j+1)%2+1; + int newRate = 1; + String cdname = cd.getSymbol(); + if((cdname.equals("SeriesRunner")) || + (cdname.equals("MDRunner"))) { + newRate = 16; + } else if(cdname.equals("SentenceParser")) { + newRate = 4; + } /*else if(cdname.equals("ReduceWorker")) { + newRate = 3; + }*/ + /*do { + tint = r.nextInt()%100; + } while(tint <= 0); + int probability = tint;*/ + int probability = 100; + pfe.addNewObjInfo(cd, newRate, probability); + } + } + } + } + + Iterator it_flags = ta.getFlagStates(cd).iterator(); + while(it_flags.hasNext()) { + FlagState fs = (FlagState)it_flags.next(); + Iterator it_edges = fs.edges(); + while(it_edges.hasNext()) { + /*do { + tint = r.nextInt()%10; + } while(tint <= 0);*/ + tint = 3; + ((FEdge)it_edges.next()).setExeTime(tint); + } + } + } + } + + // generate multiple schedulings + ScheduleAnalysis scheduleAnalysis = new ScheduleAnalysis(state, ta); + scheduleAnalysis.preSchedule(); + scheduleAnalysis.scheduleAnalysis(); + //scheduleAnalysis.setCoreNum(scheduleAnalysis.getSEdges4Test().size()); + scheduleAnalysis.setCoreNum(state.CORENUM); + scheduleAnalysis.schedule(); + + //simulate these schedulings + ScheduleSimulator scheduleSimulator = new ScheduleSimulator(scheduleAnalysis.getCoreNum(), state, ta); + Iterator it_scheduling = scheduleAnalysis.getSchedulingsIter(); + int index = 0; + Vector selectedScheduling = new Vector(); + int processTime = Integer.MAX_VALUE; + while(it_scheduling.hasNext()) { + Vector scheduling = (Vector)it_scheduling.next(); + scheduleSimulator.setScheduling(scheduling); + int tmpTime = scheduleSimulator.process(); + if(tmpTime < processTime) { + selectedScheduling.clear(); + selectedScheduling.add(index); + processTime = tmpTime; + } else if(tmpTime == processTime) { + selectedScheduling.add(index); + } + index++; + } + System.out.print("Selected schedulings with least exectution time " + processTime + ": \n\t"); + for(int i = 0; i < selectedScheduling.size(); i++) { + System.out.print((selectedScheduling.elementAt(i) + 1) + ", "); + } + System.out.println(); + + /*ScheduleSimulator scheduleSimulator = new ScheduleSimulator(4, state, ta); + Vector scheduling = new Vector(); + for(int i = 0; i < 4; i++) { + Schedule schedule = new Schedule(i); + scheduling.add(schedule); + } + Iterator it_tasks = state.getTaskSymbolTable().getAllDescriptorsIterator(); + while(it_tasks.hasNext()) { + TaskDescriptor td = (TaskDescriptor)it_tasks.next(); + if(td.getSymbol().equals("t10")) { + scheduling.elementAt(1).addTask(td); + } else { + scheduling.elementAt(0).addTask(td); + } + } + ClassDescriptor cd = (ClassDescriptor)state.getClassSymbolTable().get("E"); + scheduling.elementAt(0).addTargetCore(cd, 1); + scheduleSimulator.setScheduling(scheduling); + scheduleSimulator.process(); + + Vector scheduling1 = new Vector(); + for(int i = 0; i < 4; i++) { + Schedule schedule = new Schedule(i); + scheduling1.add(schedule); + } + Iterator it_tasks1 = state.getTaskSymbolTable().getAllDescriptorsIterator(); + while(it_tasks1.hasNext()) { + TaskDescriptor td = (TaskDescriptor)it_tasks1.next(); + scheduling1.elementAt(0).addTask(td); + } + scheduleSimulator.setScheduling(scheduling1); + scheduleSimulator.process();*/ + + // Close the streams. + try { + stdout.close (); + System.setOut(origOut); + } catch (Exception e) { + origOut.println ("Redirect: Unable to close files!"); + } + + if(state.MULTICORE) { + //it_scheduling = scheduleAnalysis.getSchedulingsIter(); + //Vector scheduling = (Vector)it_scheduling.next(); + Vector scheduling = scheduleAnalysis.getSchedulings().elementAt(selectedScheduling.elementAt(0)); + BuildCodeMultiCore bcm=new BuildCodeMultiCore(state, bf.getMap(), tu, sa, scheduling, scheduleAnalysis.getCoreNum(), pa); + bcm.buildCode(); + } + } } - if (state.DSM) { - CallGraph callgraph=new CallGraph(state); - LocalityAnalysis la=new LocalityAnalysis(state, callgraph, tu); - GenerateConversions gc=new GenerateConversions(la, state); - BuildCode bc=new BuildCode(state, bf.getMap(), tu, la); - bc.buildCode(); - } else { - BuildCode bc=new BuildCode(state, bf.getMap(), tu); - bc.buildCode(); + if(!state.MULTICORE) { + if (state.DSM) { + 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(); + } + } + + if (state.FLATIRGRAPH) { + FlatIRGraph firg = new FlatIRGraph(state, + state.FLATIRGRAPHTASKS, + state.FLATIRGRAPHUSERMETHODS, + state.FLATIRGRAPHLIBMETHODS); } + + if (state.OWNERSHIP) { + CallGraph callGraph = new CallGraph( state ); + int allocationDepth = 3; + OwnershipAnalysis oa = + new OwnershipAnalysis( state, callGraph, allocationDepth ); + //This was breaking the compile + // oa.writeAllAliases( "identifiedAliases.txt" ); + } + System.exit(0); }