more changes

diff --git a/Robust/src/Analysis/TaskStateAnalysis/TagState.java b/Robust/src/Analysis/TaskStateAnalysis/TagState.java
index 925ed8187566a84fc027e0c645aeafa08a544c74..91b505ec76b2e286e08af546e293552008c06413 100644 (file)
--- a/Robust/src/Analysis/TaskStateAnalysis/TagState.java
+++ b/Robust/src/Analysis/TaskStateAnalysis/TagState.java
@@ -8,16 +8,28 @@ import Util.GraphNode;
 
 public class TagState extends GraphNode {
     private TagDescriptor tag;
+    private ClassDescriptor cd;
     private Hashtable<FlagState, Integer> flags;
     public static final int KLIMIT=2;
+    public HashSet<TaskDescriptor> sourceset;
 
     public TagState() {
        this(null);
     }
 
+    public TagState(ClassDescriptor cd) {
+       this(null);
+       this.cd=cd;
+    }
+
+    public void addSource(TaskDescriptor td) {
+       sourceset.add(td);
+    }
+
     public TagState(TagDescriptor tag) {
        this.tag=tag;
        this.flags=new Hashtable<FlagState, Integer>();
+       this.sourceset=new HashSet,TaskDescriptor>();
     }
 
     public TagDescriptor getTag() {

diff --git a/Robust/src/Analysis/TaskStateAnalysis/TagWrapper.java b/Robust/src/Analysis/TaskStateAnalysis/TagWrapper.java
index 7e48b82fcddc0a017cda0971fdaf04f5b29bf50a..2a6b96f8282735ced997afa1cc48f95bffbca853 100644 (file)
--- a/Robust/src/Analysis/TaskStateAnalysis/TagWrapper.java
+++ b/Robust/src/Analysis/TaskStateAnalysis/TagWrapper.java
@@ -17,6 +17,11 @@ public class TagWrapper implements Wrapper {
     private TagWrapper() {
     }
 
+    public TagState getState() {
+       assert(ts.size()==1);
+       return ts.iterator().next();
+    }
+
     public TagWrapper clone() {
        TagWrapper tw=new TagWrapper();
        tw.initts=initts;

diff --git a/Robust/src/Analysis/TaskStateAnalysis/TaskBinding.java b/Robust/src/Analysis/TaskStateAnalysis/TaskBinding.java
index 27d46c47f468e1e133c9b2473622a3a92b85e7af..b3911b985a0f89700c332734e8c0b753f06fba3c 100644 (file)
--- a/Robust/src/Analysis/TaskStateAnalysis/TaskBinding.java
+++ b/Robust/src/Analysis/TaskStateAnalysis/TaskBinding.java
@@ -91,19 +91,19 @@ public class TaskBinding {
                    FlagTagState fts=tqi.ftsarray[objindex];
                    ObjWrapper ow=new ObjWrapper(fts.fs);
                    Hashtable <TagState,Set<TagWrapper>> ctable=new Hashtable<TagState, Set<TagWrapper>>();
-                   ctable.put(tw.ts, new HashSet<TagWrapper>());
-                   ctable.get(tw.ts).add(tw);
+                   ctable.put(tw.getState(), new HashSet<TagWrapper>());
+                   ctable.get(tw.getState()).add(tw);
                    ow.tags.add(tw);
                    TagExpressionList tel=tqi.tq.task.getTag(tqi.tq.task.getParameter(i));
                    for(int j=0;j<tel.numTags();j++) {
                        TempDescriptor tagtmp=tel.getTemp(j);
                        TagWrapper twtmp=temptotag.get(tagtmp);
                        if (!ctable.containsKey(twtmp.ts))
-                           ctable.put(twtmp.ts, new HashSet<TagWrapper>());
-                       ctable.get(twtmp.ts).add(twtmp);
+                           ctable.put(twtmp.getState(), new HashSet<TagWrapper>());
+                       ctable.get(twtmp.getState()).add(twtmp);
                        ow.tags.add(twtmp);
                        int tagcount=ctable.get(twtmp.ts).size();
-                       int fstagcount=fts.fs.getTagCount(twtmp.ts.getTag());
+                       int fstagcount=fts.fs.getTagCount(twtmp.getState().getTag());
                        if (fstagcount>=0&&(tagcount>fstagcount)) {
                            //Too many unique tags of this type bound to object wrapper
                            incrementlevel=i;

diff --git a/Robust/src/Analysis/TaskStateAnalysis/TaskTagAnalysis.java b/Robust/src/Analysis/TaskStateAnalysis/TaskTagAnalysis.java
index 09b8c6d9307f010bccf2d2129361c21e4dd37343..78a230f086a89ca968dee297ed7ed406856f9850 100644 (file)
--- a/Robust/src/Analysis/TaskStateAnalysis/TaskTagAnalysis.java
+++ b/Robust/src/Analysis/TaskStateAnalysis/TaskTagAnalysis.java
@@ -13,8 +13,11 @@ public class TaskTagAnalysis {
     TypeUtil typeutil;
     FlagInfo flaginfo;
     HashSet<TagState> toprocess;
+    HashSet<TagState> discovered;
     Hashtable<TaskDescriptor, TaskQueue> tasktable;
-    
+    Hashtable<TagDescriptor, Set<TagState>> tsresults;
+    Hashtable<ClassDescriptor, Set<FlagState>> fsresults;
+
 
     /** 
      * Class Constructor
@@ -26,7 +29,12 @@ public class TaskTagAnalysis {
        this.taganalysis=taganalysis;
        this.flaginfo=new FlagInfo(state);
        this.toprocess=new HashSet<TagState>();
+       this.discovered=new HashSet<TagState>();
        this.tasktable=new Hashtable<TaskDescriptor, TaskQueue>();
+       this.tsresults=new Hashtable<TagDescriptor, Set<TagState>>();
+       this.fsresults=new Hashtable<ClassDescriptor, Set<FlagState>>();
+       
+
        for(Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();taskit.hasNext();) {
            TaskDescriptor td=(TaskDescriptor)taskit.next();
            tasktable.put(td, new TaskQueue(td));
@@ -302,7 +310,7 @@ public class TaskTagAnalysis {
        }
     }
 
-    private void evalNewNode(FlatFlagActionNode fn, Hashtable<TempDescriptor, Wrapper> table) {
+    private void evalNewNode(FlatFlagActionNode fn, Hashtable<TempDescriptor, Wrapper> table, TaskDescriptor td) {
        TempDescriptor fntemp=null;
        {
            /* Compute type */
@@ -345,12 +353,24 @@ public class TaskTagAnalysis {
            else
                throw new Error("Can't clear tag in newly allocated object");
        }
+       for(Iterator<FlagState> fsit=ow.fs.iterator();fsit.hasNext();) {
+           FlagState fs2=fsit.ext();
+           fs2.addAllocatingTask(td);
+           TagState ts2=new TagState(fs2.getClassDesc());
+           ts2.addFS(fs2);
+           ts2=canonical(ts2);
+           ts2.addSource(td);
+           if (!discovered.contains(ts2)) {
+               discovered.add(ts2);
+               toprocess.add(ts2);
+           }
+       }
     }
 
-    private void processFlatTag(FlatTagDeclaration fn, Hashtable<TempDescriptor, Wrapper> table) {
+    private void processFlatTag(FlatTagDeclaration fn, Hashtable<TempDescriptor, Wrapper> table, TaskDescriptor td) {
        TempDescriptor tmp=fn.getDst();
        if (table.containsKey(tmp)) {
-           recordtagchange((TagWrapper)table.get(tmp));
+           recordtagchange((TagWrapper)table.get(tmp), td);
        }
        TagDescriptor tag=fn.getType();
        TagState ts=canonical(new TagState(tag));
@@ -359,14 +379,30 @@ public class TaskTagAnalysis {
        table.put(tmp, tw);
     }
 
-    public void recordtagchange(TagWrapper tw) {
+    private void addresult(TagDescriptor td, TagState ts) {
+       if (!tsresults.containsKey(td))
+           tsresults.put(td, new HashSet<TagState>());
+       tsresults.get(td).add(ts);
     }
-      
+
+    public void recordtagchange(TagWrapper tw, TaskDescriptor td) {
+       assert(tw.initts==null);
+       for(Iterator<TagState> tsit=tw.ts.iterator(); tsit.hasNext();) {
+           TagState ts=tsit.next();
+           ts.addSource(td);
+           addresult(ts.getTag(), ts);
+           if (!discovered.contains(ts)) {
+               discovered.add(ts);
+               toprocess.add(ts);
+           }
+       }
+    }
+    
     private void processFlatCall(FlatCall fc, Hashtable<TempDescriptor, Wrapper> table) {
        //Do nothing for now
     }
-
-    private void processFlatReturnNode(FlatReturnNode fr, Hashtable<TempDescriptor, Wrapper> table) {
+    
+    private void processFlatReturnNode(FlatReturnNode fr, Hashtable<TempDescriptor, Wrapper> table, TaskDescriptor td) {
 
     }
 
@@ -428,13 +464,13 @@ public class TaskTagAnalysis {
                processFlatFlag((FlatFlagActionNode)fn, table);
                break;
            case FKind.FlatTagDeclaration:
-               processFlatTag((FlatTagDeclaration)fn, table);
+               processFlatTag((FlatTagDeclaration)fn, table, td);
                break;
            case FKind.FlatCall:
                processFlatCall((FlatCall)fn, table);
                break;
            case FKind.FlatReturnNode:
-               processFlatReturnNode((FlatReturnNode)fn, table);
+               processFlatReturnNode((FlatReturnNode)fn, table, td);
                break;
            default:
            }