Robust/src/Analysis/MLP/AccSet.java

   1 package Analysis.MLP;
   2
   3 import java.util.HashSet;
   4 import java.util.Hashtable;
   5 import java.util.Iterator;
   6
   7 import IR.Flat.TempDescriptor;
   8
   9 public class AccSet {
  10
  11         private Hashtable<TempDescriptor, HashSet<AccKey>> readTable;
  12         private Hashtable<TempDescriptor, HashSet<AccKey>> writeTable;
  13
  14         public AccSet() {
  15
  16                 readTable = new Hashtable<TempDescriptor, HashSet<AccKey>>();
  17                 writeTable = new Hashtable<TempDescriptor, HashSet<AccKey>>();
  18
  19         }
  20
  21         public void addReadingVar(TempDescriptor td, AccKey access) {
  22                 HashSet<AccKey> aSet = readTable.get(td);
  23                 if (aSet == null) {
  24                         aSet = new HashSet<AccKey>();
  25                 }
  26
  27                 aSet.add(access);
  28                 readTable.put(td, aSet);
  29         }
  30
  31         public void addWritingVar(TempDescriptor td, AccKey access) {
  32
  33                 HashSet<AccKey> aSet = writeTable.get(td);
  34                 if (aSet == null) {
  35                         aSet = new HashSet<AccKey>();
  36                 }
  37
  38                 aSet.add(access);
  39                 writeTable.put(td, aSet);
  40
  41         }
  42
  43         public boolean containsParam(TempDescriptor td) {
  44
  45                 Iterator<TempDescriptor> iter = readTable.keySet().iterator();
  46
  47                 while (iter.hasNext()) {
  48
  49                         TempDescriptor key = iter.next();
  50                         if (key.equals(td)) {
  51                                 return true;
  52                         }
  53
  54                 }
  55
  56                 return false;
  57
  58         }
  59
  60         public void addParam(TempDescriptor paramTD) {
  61
  62                 if (!readTable.containsKey(paramTD)) {
  63                         HashSet<AccKey> readSet = new HashSet<AccKey>();
  64                         readTable.put(paramTD, readSet);
  65                 }
  66
  67                 if (!writeTable.containsKey(paramTD)) {
  68                         HashSet<AccKey> writeSet = new HashSet<AccKey>();
  69                         writeTable.put(paramTD, writeSet);
  70                 }
  71
  72         }
  73
  74         public void addAll(AccSet newAccSet) {
  75
  76                 Hashtable<TempDescriptor, HashSet<AccKey>> newReadTable = newAccSet
  77                                 .getReadTable();
  78                 Hashtable<TempDescriptor, HashSet<AccKey>> newWriteTable = newAccSet
  79                                 .getWriteTable();
  80
  81                 Iterator<TempDescriptor> iter = newReadTable.keySet().iterator();
  82                 while (iter.hasNext()) { // for each variables
  83                         TempDescriptor td = iter.next();
  84
  85                         HashSet<AccKey> currentSet;
  86                         if (!readTable.containsKey(td)) {
  87                                 currentSet = new HashSet<AccKey>();
  88                         } else {
  89                                 currentSet = readTable.get(td);
  90                         }
  91
  92                         HashSet<AccKey> newSet = newReadTable.get(td);
  93                         currentSet.addAll(newSet);
  94                         readTable.put(td, currentSet);
  95                 }
  96
  97                 iter = newWriteTable.keySet().iterator();
  98                 while (iter.hasNext()) { // for each variables
  99                         TempDescriptor td = iter.next();
 100
 101                         HashSet<AccKey> currentSet;
 102                         if (!writeTable.containsKey(td)) {
 103                                 currentSet = new HashSet<AccKey>();
 104                         } else {
 105                                 currentSet = writeTable.get(td);
 106                         }
 107
 108                         HashSet<AccKey> newSet = newWriteTable.get(td);
 109                         currentSet.addAll(newSet);
 110                         writeTable.put(td, currentSet);
 111                 }
 112
 113         }
 114
 115         public Hashtable<TempDescriptor, HashSet<AccKey>> getReadTable() {
 116                 return readTable;
 117         }
 118
 119         public Hashtable<TempDescriptor, HashSet<AccKey>> getWriteTable() {
 120                 return writeTable;
 121         }
 122
 123         public boolean equals(Object o) {
 124                 if (o == null) {
 125                         return false;
 126                 }
 127
 128                 if (!(o instanceof AccSet)) {
 129                         return false;
 130                 }
 131
 132                 AccSet in = (AccSet) o;
 133
 134                 if (getReadTable().equals(in.getReadTable())
 135                                 && getWriteTable().equals(in.getWriteTable())) {
 136                         return true;
 137                 } else {
 138                         return false;
 139                 }
 140
 141         }
 142
 143         public void printSet() {
 144
 145                 String readStr = "";
 146                 String writeStr = "";
 147
 148                 readStr = "#Reading#\r\n";
 149                 Iterator<TempDescriptor> iter = getReadTable().keySet().iterator();
 150                 while (iter.hasNext()) { // for each variables
 151
 152                         TempDescriptor td = iter.next();
 153                         HashSet<AccKey> aSet = readTable.get(td);
 154
 155                         readStr += td.getSymbol() + ":" + "{";
 156
 157                         Iterator<AccKey> setIter = aSet.iterator();
 158                         while (setIter.hasNext()) {
 159                                 AccKey element = setIter.next();
 160                                 readStr += " " + element;
 161                         }
 162                         readStr += "}\r\n";
 163                 }
 164
 165                 writeStr = "#Writing#\r\n";
 166                 iter = getWriteTable().keySet().iterator();
 167                 while (iter.hasNext()) { // for each variables
 168
 169                         TempDescriptor td = iter.next();
 170                         HashSet<AccKey> aSet = writeTable.get(td);
 171
 172                         writeStr += td.getSymbol() + ":" + "{";
 173
 174                         Iterator<AccKey> setIter = aSet.iterator();
 175                         while (setIter.hasNext()) {
 176                                 AccKey element = setIter.next();
 177                                 writeStr += " " + element;
 178                         }
 179                         writeStr += "}\r\n";
 180                 }
 181
 182                 System.out.println(readStr);
 183                 System.out.println(writeStr);
 184
 185         }
 186
 187         public String toString() {
 188
 189                 String str = "\n";
 190
 191                 Iterator<TempDescriptor> iter = getReadTable().keySet().iterator();
 192                 while (iter.hasNext()) { // for each variables
 193
 194                         TempDescriptor td = iter.next();
 195
 196                         str += "\tParameter " + td.getSymbol() + " reading={";
 197
 198                         HashSet<AccKey> aSet = readTable.get(td);
 199                         Iterator<AccKey> setIter = aSet.iterator();
 200                         boolean first = true;
 201                         while (setIter.hasNext()) {
 202                                 AccKey element = setIter.next();
 203                                 if (first) {
 204                                         str += " " + element;
 205                                         first = false;
 206                                 } else {
 207                                         str += " , " + element;
 208                                 }
 209
 210                         }
 211                         str += " }\n";
 212
 213                         str += "\tParameter " + td.getSymbol() + " writing={";
 214
 215                         aSet = writeTable.get(td);
 216                         setIter = aSet.iterator();
 217                         first = true;
 218                         while (setIter.hasNext()) {
 219                                 AccKey element = setIter.next();
 220                                 if (first) {
 221                                         str += " " + element;
 222                                         first = false;
 223                                 } else {
 224                                         str += " , " + element;
 225                                 }
 226
 227                         }
 228                         str += " }\n";
 229
 230                 }
 231
 232                 return str;
 233         }
 234
 235 }