X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FAnalysis%2FTaskStateAnalysis%2FTaskAnalysis.java;h=bba02a6edb955f4bcfa990bb7ff06f95ed6e9105;hb=4cb63e913202459da4fe9d01feb7c02f1b98dd6f;hp=cb8cf7022d805352360dfdb71f492f5743ad202d;hpb=7878f13f1e1ef17792a12adf59fc4f89dacc8229;p=IRC.git diff --git a/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java b/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java index cb8cf702..bba02a6e 100644 --- a/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java +++ b/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java @@ -15,6 +15,7 @@ public class TaskAnalysis { Queue toprocess; TagAnalysis taganalysis; Hashtable cdtorootnodes; + Hashtable tdToFEdges; TypeUtil typeutil; @@ -24,50 +25,44 @@ public class TaskAnalysis { * @param state a flattened State object * @see State */ - public TaskAnalysis(State state, TagAnalysis taganalysis) - { + public TaskAnalysis(State state, TagAnalysis taganalysis) { this.state=state; this.typeutil=new TypeUtil(state); this.taganalysis=taganalysis; - } - /** Builds a table of flags for each class in the Bristlecone program. - * It creates two hashtables: one which holds the ClassDescriptors and arrays of - * FlagDescriptors as key-value pairs; the other holds the ClassDescriptor and the - * number of external flags for that specific class. + /** Builds a table of flags for each class in the Bristlecone + * program. It creates two hashtables: one which holds the + * ClassDescriptors and arrays of * FlagDescriptors as key-value + * pairs; the other holds the ClassDescriptor and the * number of + * external flags for that specific class. */ private void getFlagsfromClasses() { flags=new Hashtable(); extern_flags = new Hashtable(); - /** Iterate through the classes used in the program to build the table of flags + /** Iterate through the classes used in the program to build + * the table of flags */ for(Iterator it_classes=state.getClassSymbolTable().getDescriptorsIterator();it_classes.hasNext();) { ClassDescriptor cd = (ClassDescriptor)it_classes.next(); - System.out.println(cd.getSymbol()); Vector vFlags=new Vector(); FlagDescriptor flag[]; int ctr=0; /* Adding the flags of the super class */ - if (cd.getSuper()!=null) { - ClassDescriptor superdesc=cd.getSuperDesc(); - - for(Iterator it_cflags=superdesc.getFlags();it_cflags.hasNext();) { + ClassDescriptor tmp=cd; + while(tmp!=null) { + for(Iterator it_cflags=tmp.getFlags();it_cflags.hasNext();) { FlagDescriptor fd = (FlagDescriptor)it_cflags.next(); - System.out.println(fd.toString()); vFlags.add(fd); } + tmp=tmp.getSuperDesc(); } - for(Iterator it_cflags=cd.getFlags();it_cflags.hasNext();) { - FlagDescriptor fd = (FlagDescriptor)it_cflags.next(); - vFlags.add(fd); - } if (vFlags.size()!=0) { flag=new FlagDescriptor[vFlags.size()]; @@ -88,14 +83,14 @@ public class TaskAnalysis { } } } - /** Method which starts up the analysis - * + /** Method which starts up the analysis */ public void taskAnalysis() throws java.io.IOException { flagstates=new Hashtable(); Hashtable sourcenodes; cdtorootnodes=new Hashtable(); + tdToFEdges=new Hashtable(); getFlagsfromClasses(); @@ -106,13 +101,6 @@ public class TaskAnalysis { ClassDescriptor cd=(ClassDescriptor)it_classes.next(); externs=((Integer)extern_flags.get(cd)).intValue(); FlagDescriptor[] fd=(FlagDescriptor[])flags.get(cd); - - //Debug block - System.out.println("Inside taskAnalysis;\n Class:"+ cd.getSymbol()); - System.out.println("No of externs " + externs); - System.out.println("No of flags: "+fd.length); - //Debug block - flagstates.put(cd,new Hashtable()); cdtorootnodes.put(cd,new Vector()); } @@ -133,25 +121,20 @@ public class TaskAnalysis { sourcenodes.put(fsstartup,fsstartup); toprocess.add(fsstartup); - /** Looping through the flagstates in the toprocess queue to perform the state analysis */ + /** Looping through the flagstates in the toprocess queue to + * perform the state analysis */ while (!toprocess.isEmpty()) { FlagState trigger=toprocess.poll(); createPossibleRuntimeStates(trigger); analyseTasks(trigger); } - - /** Creating DOT files */ Enumeration e=flagstates.keys(); while (e.hasMoreElements()) { - System.out.println("creating dot file"); ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement(); - System.out.println((cdtemp.getSymbol())); - - createDOTfile(cdtemp); } } @@ -172,29 +155,31 @@ private void analyseTasks(FlagState fs) { TaskDescriptor td = (TaskDescriptor)it_tasks.next(); String taskname=td.getSymbol(); - //**Debug***/ - System.out.println(); - System.out.println(cd.getSymbol()+" : "+fs.getTextLabel()); - System.out.println("Task: "+taskname); - //*********** - - /** counter to keep track of the number of parameters (of the task being analyzed) that - * are satisfied by the flagstate. + if(!tdToFEdges.containsKey(td)) { + tdToFEdges.put(td, new Vector()); + } + + /** counter to keep track of the number of parameters (of the + * task being analyzed) that are satisfied by the flagstate. */ int trigger_ctr=0; TempDescriptor temp=null; FlatMethod fm = state.getMethodFlat(td); - + int parameterindex=0; + for(int i=0; i < td.numParameters(); i++) { FlagExpressionNode fen=td.getFlag(td.getParameter(i)); TagExpressionList tel=td.getTag(td.getParameter(i)); - /** Checking to see if the parameter is of the same type/class as the - * flagstate's and also if the flagstate fs triggers the given task*/ + /** Checking to see if the parameter is of the same + * type/class as the flagstate's and also if the + * flagstate fs triggers the given task*/ + if (typeutil.isSuperorType(td.getParamType(i).getClassDesc(),cd) && isTaskTrigger_flag(fen,fs) && isTaskTrigger_tag(tel,fs)) { temp=fm.getParameter(i); + parameterindex=i; trigger_ctr++; } } @@ -203,23 +188,25 @@ private void analyseTasks(FlagState fs) { continue; if (trigger_ctr>1) - throw new Error("Illegal Operation: A single flagstate cannot satisfy more than one parameter of a task."); - - - //** debug - System.out.println("Task:" + taskname +" is triggered"); + System.out.println("Illegal Operation: A single flagstate cannot satisfy more than one parameter of a task:"+fs + " in "+td); Set newstates=taganalysis.getFlagStates(td); for(Iterator fsit=newstates.iterator();fsit.hasNext();) { FlagState fsnew=(FlagState) fsit.next(); - fsnew.setAsSourceNode(); - fsnew.addAllocatingTask(td); - ((Vector)cdtorootnodes.get(fsnew.getClassDescriptor())).add(fsnew); + System.out.println("SOURCE:"+fsnew); if (! ((Hashtable)flagstates.get(fsnew.getClassDescriptor())).containsKey(fsnew)) { ((Hashtable)flagstates.get(fsnew.getClassDescriptor())).put(fsnew, fsnew); toprocess.add(fsnew); + } else { + fsnew=((Hashtable)flagstates.get(fsnew.getClassDescriptor())).get(fsnew); + } + fsnew.setAsSourceNode(); + fsnew.addAllocatingTask(td); + + if(!((Vector)cdtorootnodes.get(fsnew.getClassDescriptor())).contains(fsnew)) { + ((Vector)cdtorootnodes.get(fsnew.getClassDescriptor())).add(fsnew); } } @@ -234,7 +221,8 @@ private void analyseTasks(FlagState fs) { if (fn1.kind()==FKind.FlatReturnNode) { /* Self edge */ - FEdge newedge=new FEdge(fs, taskname); + FEdge newedge=new FEdge(fs, taskname, td, parameterindex); + ((Vector)tdToFEdges.get(td)).add(newedge); fs.addEdge(newedge); continue; } else if (fn1.kind()==FKind.FlatFlagActionNode) { @@ -244,23 +232,26 @@ private void analyseTasks(FlagState fs) { throw new Error("PRE FlagActions not supported"); } else if (ffan.getTaskType() == FlatFlagActionNode.TASKEXIT) { - //*** - System.out.println("TASKEXIT"); - //*** - Vector fsv_taskexit=evalTaskExitNode(ffan,cd,fs,temp); - + Vector initFStates = ffan.getInitFStates(temp.getType().getClassDesc()); + if(!initFStates.contains(fs)) { + initFStates.addElement(fs); + } + Vector targetFStates = ffan.getTargetFStates(fs); for(Enumeration en=fsv_taskexit.elements();en.hasMoreElements();){ FlagState fs_taskexit=(FlagState)en.nextElement(); if (!sourcenodes.containsKey(fs_taskexit)) { toprocess.add(fs_taskexit); - } //seen this node already fs_taskexit=canonicalizeFlagState(sourcenodes,fs_taskexit); - FEdge newedge=new FEdge(fs_taskexit,taskname); - //FEdge newedge=new FEdge(fs_taskexit,td); + FEdge newedge=new FEdge(fs_taskexit,taskname, td, parameterindex); + ((Vector)tdToFEdges.get(td)).add(newedge); fs.addEdge(newedge); + + if(!targetFStates.contains(fs_taskexit)) { + targetFStates.addElement(fs_taskexit); + } } continue; } @@ -289,7 +280,7 @@ private void analyseTasks(FlagState fs) { */ -private boolean isTaskTrigger_flag(FlagExpressionNode fen,FlagState fs) { +public static boolean isTaskTrigger_flag(FlagExpressionNode fen,FlagState fs) { if (fen==null) return true; else if (fen instanceof FlagNode) @@ -323,14 +314,6 @@ private boolean isTaskTrigger_tag(TagExpressionList tel, FlagState fs){ return true; } -/*private int tagTypeCount(TagExpressionList tel, String tagtype){ - int ctr=0; - for(int i=0;i evalTaskExitNode(FlatFlagActionNode ffan,ClassDescriptor cd,FlagState fs, TempDescriptor temp){ FlagState fstemp=fs; @@ -348,6 +331,23 @@ private boolean isTaskTrigger_tag(TagExpressionList tel, FlagState fs){ processed.add(fstemp); + //Process clears first + for(Iterator it_ttp=ffan.getTempTagPairs();it_ttp.hasNext();) { + TempTagPair ttp=(TempTagPair)it_ttp.next(); + + if (temp==ttp.getTemp()) { + Vector oldprocess=processed; + processed=new Vector(); + + for (Enumeration en=oldprocess.elements();en.hasMoreElements();){ + FlagState fsworking=(FlagState)en.nextElement(); + if (!ffan.getTagChange(ttp)){ + processed.addAll(Arrays.asList(fsworking.clearTag(ttp.getTag()))); + } else processed.add(fsworking); + } + } + } + //Process sets next for(Iterator it_ttp=ffan.getTempTagPairs();it_ttp.hasNext();) { TempTagPair ttp=(TempTagPair)it_ttp.next(); @@ -359,14 +359,11 @@ private boolean isTaskTrigger_tag(TagExpressionList tel, FlagState fs){ FlagState fsworking=(FlagState)en.nextElement(); if (ffan.getTagChange(ttp)){ processed.addAll(Arrays.asList(fsworking.setTag(ttp.getTag()))); - } else { - processed.addAll(Arrays.asList(fsworking.clearTag(ttp.getTag()))); - } + } else processed.add(fsworking); } } } return processed; - } @@ -386,62 +383,62 @@ private boolean isTaskTrigger_tag(TagExpressionList tel, FlagState fs){ */ public void createDOTfile(ClassDescriptor cd) throws java.io.IOException { - File dotfile_flagstates= new File("graph"+cd.getSymbol()+".dot"); - FileOutputStream dotstream=new FileOutputStream(dotfile_flagstates,true); - FlagState.DOTVisitor.visit(dotstream,((Hashtable)flagstates.get(cd)).values()); - + File dotfile_flagstates= new File("graph"+cd.getSymbol()+".dot"); + FileOutputStream dotstream=new FileOutputStream(dotfile_flagstates,false); + FlagState.DOTVisitor.visit(dotstream,((Hashtable)flagstates.get(cd)).values()); } /** Returns the flag states for the class descriptor. */ - public Set getFlagStates(ClassDescriptor cd) { + public Set getFlagStates(ClassDescriptor cd) { if (flagstates.containsKey(cd)) - return ((Hashtable)flagstates.get(cd)).keySet(); + return ((Hashtable)flagstates.get(cd)).keySet(); else - return null; + return new HashSet(); } private void createPossibleRuntimeStates(FlagState fs) { - ClassDescriptor cd = fs.getClassDescriptor(); - Hashtable sourcenodes=(Hashtable)flagstates.get(cd); - FlagDescriptor[] fd=(FlagDescriptor[])flags.get(cd); - int externs=((Integer)extern_flags.get(cd)).intValue(); - - if(externs==0) - return; - - int noOfIterations=(1< sourcenodes=(Hashtable)flagstates.get(cd); + FlagDescriptor[] fd=(FlagDescriptor[])flags.get(cd); + int externs=((Integer)extern_flags.get(cd)).intValue(); - FlagState fstemp=fs; + if(externs==0) + return; + + int noOfIterations=(1<