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 == null ) {
 104             return false;
 105         }
 106
 107         if( !(o instanceof TokenTupleSet) ) {
 108             return false;
 109         }
 110
 111         TokenTupleSet tts = (TokenTupleSet) o;
 112         return tokenTuples.equals( tts.tokenTuples );
 113     }
 114
 115     public int hashCode() {
 116         return tokenTuples.hashCode();
 117     }
 118
 119     /*
 120     public boolean equalWithoutArity( TokenTupleSet ttsIn ) {
 121         Iterator itrIn = ttsIn.iterator();
 122         while( itrIn.hasNext() ) {
 123             TokenTuple ttIn = (TokenTuple) itrIn.next();
 124
 125             if( !this.containsToken( ttIn.getToken() ) )
 126             {
 127                 return false;
 128             }
 129         }
 130
 131         Iterator itrThis = this.iterator();
 132         while( itrThis.hasNext() ) {
 133             TokenTuple ttThis = (TokenTuple) itrThis.next();
 134
 135             if( !ttsIn.containsToken( ttThis.getToken() ) )
 136             {
 137                 return false;
 138             }
 139         }
 140
 141         return true;
 142     }
 143     */
 144
 145     // this should be a hash table so we can do this by key
 146     public boolean containsToken( Integer token ) {
 147         Iterator itr = tokenTuples.iterator();
 148         while( itr.hasNext() ) {
 149             TokenTuple tt = (TokenTuple) itr.next();
 150             if( token.equals( tt.getToken() ) ) {
 151                 return true;
 152             }
 153         }
 154         return false;
 155     }
 156
 157     public TokenTupleSet ageTokens( AllocationSite as ) {
 158         TokenTupleSet ttsOut = new TokenTupleSet();
 159
 160         TokenTuple ttSummary = null;
 161         boolean foundOldest  = false;
 162
 163         Iterator itrT = this.iterator();
 164         while( itrT.hasNext() ) {
 165             TokenTuple tt = (TokenTuple) itrT.next();
 166
 167             Integer token = tt.getToken();
 168             int age = as.getAge( token );
 169
 170             // summary tokens and tokens not associated with
 171             // the site should be left alone
 172             if( age == AllocationSite.AGE_notInThisSite ) {
 173                 ttsOut.tokenTuples.add( tt );
 174
 175             } else {
 176                 if( age == AllocationSite.AGE_summary ) {
 177                     // remember the summary tuple, but don't add it
 178                     // we may combine it with the oldest tuple
 179                     ttSummary = tt;
 180
 181                 } else if( age == AllocationSite.AGE_oldest ) {
 182                     // found an oldest token, again just remember
 183                     // for later
 184                     foundOldest = true;
 185
 186                 } else {
 187                     // otherwise, we change this token to the
 188                     // next older token
 189                     Integer tokenToChangeTo = as.getIthOldest( age + 1 );
 190                     TokenTuple ttAged       = tt.changeTokenTo( tokenToChangeTo );
 191                     ttsOut.tokenTuples.add( ttAged );
 192                 }
 193
 194             }
 195         }
 196
 197         // there are four cases to consider here
 198         // 1. we found a summary tuple and no oldest tuple
 199         //    Here we just pass the summary unchanged
 200         // 2. we found an oldest tuple, no summary
 201         //    Make a new, arity-one summary tuple
 202         // 3. we found both a summary and an oldest
 203         //    Merge them by increasing arity of summary
 204         // 4. (not handled) we found neither, do nothing
 205         if       ( ttSummary != null && !foundOldest ) {
 206             ttsOut.tokenTuples.add( ttSummary );
 207
 208         } else if( ttSummary == null &&  foundOldest ) {
 209             ttsOut.tokenTuples.add( new TokenTuple( as.getSummary(),
 210                                         true,
 211                                         TokenTuple.ARITY_ONE ).makeCanonical() );
 212
 213         } else if( ttSummary != null &&  foundOldest ) {
 214             ttsOut.tokenTuples.add( ttSummary.increaseArity() );
 215         }
 216
 217         return ttsOut.makeCanonical();
 218     }
 219
 220     public String toString() {
 221         return tokenTuples.toString();
 222     }
 223 }