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