Hashtable extern_flags;
Queue<FlagState> toprocess;
TagAnalysis taganalysis;
+ Hashtable cdtorootnodes;
TypeUtil typeutil;
this.state=state;
this.typeutil=new TypeUtil(state);
this.taganalysis=taganalysis;
+
}
/** Builds a table of flags for each class in the Bristlecone program.
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;
for(Iterator it_cflags=superdesc.getFlags();it_cflags.hasNext();) {
FlagDescriptor fd = (FlagDescriptor)it_cflags.next();
- System.out.println(fd.toString());
vFlags.add(fd);
}
}
public void taskAnalysis() throws java.io.IOException {
flagstates=new Hashtable();
Hashtable<FlagState,FlagState> sourcenodes;
-
+ cdtorootnodes=new Hashtable();
getFlagsfromClasses();
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<FlagState,FlagState>());
+ cdtorootnodes.put(cd,new Vector());
}
ClassDescriptor startupobject=typeutil.getClass(TypeUtil.StartupClass);
sourcenodes=(Hashtable<FlagState,FlagState>)flagstates.get(startupobject);
-
FlagState fsstartup=new FlagState(startupobject);
+
+
FlagDescriptor[] fd=(FlagDescriptor[])flags.get(startupobject);
fsstartup=fsstartup.setFlag(fd[0],true);
-
+ fsstartup.setAsSourceNode();
+ ((Vector)cdtorootnodes.get(startupobject)).add(fsstartup);
+
sourcenodes.put(fsstartup,fsstartup);
toprocess.add(fsstartup);
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);
}
}
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.
*/
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");
-
-
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);
+
if (! ((Hashtable<FlagState,FlagState>)flagstates.get(fsnew.getClassDescriptor())).containsKey(fsnew)) {
((Hashtable<FlagState,FlagState>)flagstates.get(fsnew.getClassDescriptor())).put(fsnew, fsnew);
toprocess.add(fsnew);
}
}
+ Stack nodestack=new Stack();
+ HashSet discovered=new HashSet();
+ nodestack.push(fm);
+ discovered.add(fm);
//Iterating through the nodes
- Set nodeset=fm.getNodeSet();
- for(Iterator nodeit=nodeset.iterator();nodeit.hasNext();) {
- FlatNode fn1 = (FlatNode) nodeit.next();
+ while(!nodestack.isEmpty()) {
+ FlatNode fn1 = (FlatNode) nodestack.pop();
- if (fn1.kind()==FKind.FlatFlagActionNode) {
+ if (fn1.kind()==FKind.FlatReturnNode) {
+ /* Self edge */
+ FEdge newedge=new FEdge(fs, taskname);
+ fs.addEdge(newedge);
+ continue;
+ } else if (fn1.kind()==FKind.FlatFlagActionNode) {
FlatFlagActionNode ffan=(FlatFlagActionNode)fn1;
if (ffan.getTaskType() == FlatFlagActionNode.PRE) {
if (ffan.getTempFlagPairs().hasNext()||ffan.getTempTagPairs().hasNext())
throw new Error("PRE FlagActions not supported");
} else if (ffan.getTaskType() == FlatFlagActionNode.TASKEXIT) {
- //***
- System.out.println("TASKEXIT");
- //***
-
Vector<FlagState> fsv_taskexit=evalTaskExitNode(ffan,cd,fs,temp);
-
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);
fs.addEdge(newedge);
}
+ continue;
+ }
+ }
+ /* Queue other nodes past this one */
+ for(int i=0;i<fn1.numNext();i++) {
+ FlatNode fnext=fn1.getNext(i);
+ if (!discovered.contains(fnext)) {
+ discovered.add(fnext);
+ nodestack.push(fnext);
}
}
}
private boolean isTaskTrigger_flag(FlagExpressionNode fen,FlagState fs) {
- if (fen instanceof FlagNode)
+ if (fen==null)
+ return true;
+ else if (fen instanceof FlagNode)
return fs.get(((FlagNode)fen).getFlag());
else
switch (((FlagOpNode)fen).getOp().getOp()) {
return ctr;
} */
-/** Evaluates a NewObject Node and returns the newly created
- * flagstate to add to the process queue.
- * @param nn FlatNode
- * @return FlagState
- * @see FlatNode
- * @see FlagState
- */
-
-private FlagState evalNewObjNode(FlatNode nn){
-
- ClassDescriptor cd_new=((FlatNew)nn.getPrev(0)).getType().getClassDesc();
-
-
- //TempDescriptor[] tdArray = ((FlatFlagActionNode)nn).readsTemps();
-
- //if (tdArray.length==0)
- // return null;
-
- //Under the safe assumption that all the temps in FFAN.NewObject node are of the same type(class)
- //ClassDescriptor cd_new=tdArray[0].getType().getClassDesc();
-
- FlagState fstemp=new FlagState(cd_new);
-
- for(Iterator it_tfp=((FlatFlagActionNode)nn).getTempFlagPairs();it_tfp.hasNext();) {
- TempFlagPair tfp=(TempFlagPair)it_tfp.next();
- if (! (tfp.getFlag()==null))// condition checks if the new object was created without any flag setting
- {
- fstemp=fstemp.setFlag(tfp.getFlag(),((FlatFlagActionNode)nn).getFlagChange(tfp));
- }
+ private Vector<FlagState> evalTaskExitNode(FlatFlagActionNode ffan,ClassDescriptor cd,FlagState fs, TempDescriptor temp){
+ FlagState fstemp=fs;
+ Vector<FlagState> processed=new Vector<FlagState>();
+
+ //Process the flag changes
- else
- break;
- }
- for(Iterator it_ttp=((FlatFlagActionNode)nn).getTempTagPairs();it_ttp.hasNext();) {
- TempTagPair ttp=(TempTagPair)it_ttp.next();
- if (! (ttp.getTag()==null)){
- fstemp=fstemp.setTag(ttp.getTag());
+ for(Iterator it_tfp=ffan.getTempFlagPairs();it_tfp.hasNext();) {
+ TempFlagPair tfp=(TempFlagPair)it_tfp.next();
+ if (temp==tfp.getTemp())
+ fstemp=fstemp.setFlag(tfp.getFlag(),ffan.getFlagChange(tfp));
}
- else
- break;
- }
- return fstemp;
-}
+ //Process the tag changes
+
+ processed.add(fstemp);
- private Vector<FlagState> evalTaskExitNode(FlatNode nn,ClassDescriptor cd,FlagState fs, TempDescriptor temp){
- FlagState fstemp=fs;
- //FlagState[] fstemparray=new FlagState[3];
- Vector<FlagState> inprocess=new Vector<FlagState>();
- Vector<FlagState> processed=new Vector<FlagState>();
-
- for(Iterator it_tfp=((FlatFlagActionNode)nn).getTempFlagPairs();it_tfp.hasNext();) {
- TempFlagPair tfp=(TempFlagPair)it_tfp.next();
- if (temp==tfp.getTemp())
- fstemp=fstemp.setFlag(tfp.getFlag(),((FlatFlagActionNode)nn).getFlagChange(tfp));
- }
-
- inprocess.add(fstemp);
- processed.add(fstemp);
-
- for(Iterator it_ttp=((FlatFlagActionNode)nn).getTempTagPairs();it_ttp.hasNext();) {
- TempTagPair ttp=(TempTagPair)it_ttp.next();
-
- if (temp==ttp.getTemp()){
- processed=new Vector<FlagState>();
- for (Enumeration en=inprocess.elements();en.hasMoreElements();){
- FlagState fsworking=(FlagState)en.nextElement();
- if (((FlatFlagActionNode)nn).getTagChange(ttp)){
- fsworking=fsworking.setTag(ttp.getTag());
- processed.add(fsworking);
- }
- else
- {
- processed.addAll(Arrays.asList(fsworking.clearTag(ttp.getTag())));
- }
- }
- inprocess=processed;
- }
+ //Process clears first
+ for(Iterator it_ttp=ffan.getTempTagPairs();it_ttp.hasNext();) {
+ TempTagPair ttp=(TempTagPair)it_ttp.next();
+
+ if (temp==ttp.getTemp()) {
+ Vector<FlagState> oldprocess=processed;
+ processed=new Vector<FlagState>();
+
+ 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);
}
- return processed;
-
-}
+ }
+ }
+ //Process sets next
+ for(Iterator it_ttp=ffan.getTempTagPairs();it_ttp.hasNext();) {
+ TempTagPair ttp=(TempTagPair)it_ttp.next();
+ if (temp==ttp.getTemp()) {
+ Vector<FlagState> oldprocess=processed;
+ processed=new Vector<FlagState>();
+
+ for (Enumeration en=oldprocess.elements();en.hasMoreElements();){
+ FlagState fsworking=(FlagState)en.nextElement();
+ if (ffan.getTagChange(ttp)){
+ processed.addAll(Arrays.asList(fsworking.setTag(ttp.getTag())));
+ } else processed.add(fsworking);
+ }
+ }
+ }
+ return processed;
+ }
+
private FlagState canonicalizeFlagState(Hashtable sourcenodes, FlagState fs){
if (sourcenodes.containsKey(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,true);
+ FlagState.DOTVisitor.visit(dotstream,((Hashtable)flagstates.get(cd)).values());
}
-
+
/** Returns the flag states for the class descriptor. */
public Set getFlagStates(ClassDescriptor cd) {
if (flagstates.containsKey(cd))
}
}
+ public Vector getRootNodes(ClassDescriptor cd){
+ return (Vector)cdtorootnodes.get(cd);
+ }
-
+
+
}
projects / IRC.git / blobdiff