Robust/src/Analysis/OwnershipAnalysis/TokenTupleSet.java

   1 package Analysis.OwnershipAnalysis;
   2
   3 import IR.*;
   4 import IR.Flat.*;
   5 import java.util.*;
   6 import java.io.*;
   7
   8
   9 public class TokenTupleSet extends Canonical {
  10
  11     private HashSet<TokenTuple> tokenTuples;
  12
  13     public TokenTupleSet() {
  14         tokenTuples = new HashSet<TokenTuple>();
  15     }
  16
  17     public TokenTupleSet( TokenTuple tt ) {
  18         this();
  19         tokenTuples.add( tt );
  20     }
  21
  22     public TokenTupleSet( TokenTupleSet tts ) {
  23         tokenTuples = (HashSet<TokenTuple>) tts.tokenTuples.clone(); //COPY?!
  24     }
  25
  26     public TokenTupleSet makeCanonical() {
  27         return (TokenTupleSet) Canonical.makeCanonical( this );
  28     }
  29
  30     public Iterator iterator() {
  31         return tokenTuples.iterator();
  32     }
  33
  34     /*
  35     public TokenTupleSet add( TokenTuple tt ) {
  36         TokenTupleSet ttsOut = new TokenTupleSet( tt );
  37         return this.union( ttsOut );
  38     }
  39     */
  40
  41     public TokenTupleSet union( TokenTupleSet ttsIn ) {
  42         TokenTupleSet ttsOut = new TokenTupleSet( this );
  43         ttsOut.tokenTuples.addAll( ttsIn.tokenTuples );
  44         return ttsOut.makeCanonical();
  45     }
  46
  47     /*
  48     public TokenTupleSet unionUpArity( TokenTupleSet ttsIn ) {
  49         TokenTupleSet ttsOut = new TokenTupleSet();
  50
  51         Iterator itrIn = ttsIn.iterator();
  52         while( itrIn.hasNext() ) {
  53             TokenTuple ttIn = (TokenTuple) itrIn.next();
  54
  55             if( this.containsToken( ttIn.getToken() ) ) {
  56                 ttsOut.tokenTuples.add( ttIn.increaseArity() );
  57             } else {
  58                 ttsOut.tokenTuples.add( ttIn );
  59             }
  60         }
  61
  62         Iterator itrThis = this.iterator();
  63         while( itrThis.hasNext() ) {
  64             TokenTuple ttThis = (TokenTuple) itrThis.next();
  65
  66             if( !ttsIn.containsToken( ttThis.getToken() ) ) {
  67                 ttsOut.tokenTuples.add( ttThis );
  68             }
  69         }
  70
  71         return ttsOut.makeCanonical();
  72     }
  73     */
  74
  75     public boolean isEmpty() {
  76         return tokenTuples.isEmpty();
  77     }
  78
  79     public boolean isSubset( TokenTupleSet ttsIn ) {
  80         assert ttsIn != null;
  81         return ttsIn.tokenTuples.containsAll( this.tokenTuples );
  82     }
  83
  84     public boolean containsTuple( TokenTuple tt ) {
  85         return tokenTuples.contains( tt );
  86     }
  87
  88     // only needs to be done if newSummary is true?  RIGHT?
  89     public TokenTupleSet increaseArity( Integer token ) {
  90         TokenTuple tt
  91             = new TokenTuple( token, true, TokenTuple.ARITY_ONE ).makeCanonical();
  92         if( tokenTuples.contains( tt ) ) {
  93             tokenTuples.remove( tt );
  94             tokenTuples.add(
  95               new TokenTuple( token, true, TokenTuple.ARITY_MANY ).makeCanonical()
  96                              );
  97         }
  98
  99         return makeCanonical();
 100     }
 101
 102     public boolean equals( Object o ) {
 103         if( !(o instanceof TokenTupleSet) ) {
 104             return false;
 105         }
 106
 107         TokenTupleSet tts = (TokenTupleSet) o;
 108         return tokenTuples.equals( tts.tokenTuples );
 109     }
 110
 111     public int hashCode() {
 112         return tokenTuples.hashCode();
 113     }
 114
 115     /*
 116     public boolean equalWithoutArity( TokenTupleSet ttsIn ) {
 117         Iterator itrIn = ttsIn.iterator();
 118         while( itrIn.hasNext() ) {
 119             TokenTuple ttIn = (TokenTuple) itrIn.next();
 120
 121             if( !this.containsToken( ttIn.getToken() ) )
 122             {
 123                 return false;
 124             }
 125         }
 126
 127         Iterator itrThis = this.iterator();
 128         while( itrThis.hasNext() ) {
 129             TokenTuple ttThis = (TokenTuple) itrThis.next();
 130
 131             if( !ttsIn.containsToken( ttThis.getToken() ) )
 132             {
 133                 return false;
 134             }
 135         }
 136
 137         return true;
 138     }
 139     */
 140
 141     // this should be a hash table so we can do this by key
 142     public boolean containsToken( Integer token ) {
 143         Iterator itr = tokenTuples.iterator();
 144         while( itr.hasNext() ) {
 145             TokenTuple tt = (TokenTuple) itr.next();
 146             if( token.equals( tt.getToken() ) ) {
 147                 return true;
 148             }
 149         }
 150         return false;
 151     }
 152
 153     public TokenTupleSet ageTokens( AllocationSite as ) {
 154         TokenTupleSet ttsOut = new TokenTupleSet();
 155
 156         TokenTuple ttSummary = null;
 157         boolean foundOldest  = false;
 158
 159         Iterator itrT = this.iterator();
 160         while( itrT.hasNext() ) {
 161             TokenTuple tt = (TokenTuple) itrT.next();
 162
 163             Integer token = tt.getToken();
 164             int age = as.getAge( token );
 165
 166             // summary tokens and tokens not associated with
 167             // the site should be left alone
 168             if( age == AllocationSite.AGE_notInThisSite ) {
 169                 ttsOut.tokenTuples.add( tt );
 170
 171             } else {
 172                 if( age == AllocationSite.AGE_summary ) {
 173                     // remember the summary tuple, but don't add it
 174                     // we may combine it with the oldest tuple
 175                     ttSummary = tt;
 176
 177                 } else if( age == AllocationSite.AGE_oldest ) {
 178                     // found an oldest token, again just remember
 179                     // for later
 180                     foundOldest = true;
 181
 182                 } else {
 183                     // otherwise, we change this token to the
 184                     // next older token
 185                     Integer tokenToChangeTo = as.getIthOldest( age + 1 );
 186                     TokenTuple ttAged       = tt.changeTokenTo( tokenToChangeTo );
 187                     ttsOut.tokenTuples.add( ttAged );
 188                 }
 189
 190             }
 191         }
 192
 193         // there are four cases to consider here
 194         // 1. we found a summary tuple and no oldest tuple
 195         //    Here we just pass the summary unchanged
 196         // 2. we found an oldest tuple, no summary
 197         //    Make a new, arity-one summary tuple
 198         // 3. we found both a summary and an oldest
 199         //    Merge them by increasing arity of summary
 200         // 4. (not handled) we found neither, do nothing
 201         if       ( ttSummary != null && !foundOldest ) {
 202             ttsOut.tokenTuples.add( ttSummary );
 203
 204         } else if( ttSummary == null &&  foundOldest ) {
 205             ttsOut.tokenTuples.add( new TokenTuple( as.getSummary(),
 206                                         true,
 207                                         TokenTuple.ARITY_ONE ).makeCanonical() );
 208
 209         } else if( ttSummary != null &&  foundOldest ) {
 210             ttsOut.tokenTuples.add( ttSummary.increaseArity() );
 211         }
 212
 213         return ttsOut.makeCanonical();
 214     }
 215
 216     public String toString() {
 217         return tokenTuples.toString();
 218     }
 219 }