store_set.cc revision 1062
1#include "cpu/beta_cpu/store_set.hh" 2#include "base/trace.hh" 3 4StoreSet::StoreSet(int _SSIT_size, int _LFST_size) 5 : SSIT_size(_SSIT_size), LFST_size(_LFST_size) 6{ 7 DPRINTF(StoreSet, "StoreSet: Creating store set object.\n"); 8 DPRINTF(StoreSet, "StoreSet: SSIT size: %i, LFST size: %i.\n", 9 SSIT_size, LFST_size); 10 11 SSIT = new SSID[SSIT_size]; 12 13 validSSIT.resize(SSIT_size); 14 15 for (int i = 0; i < SSIT_size; ++i) 16 validSSIT[i] = false; 17 18 LFST = new InstSeqNum[LFST_size]; 19 20 validLFST.resize(LFST_size); 21 22 SSCounters = new int[LFST_size]; 23 24 for (int i = 0; i < LFST_size; ++i) 25 { 26 validLFST[i] = false; 27 SSCounters[i] = 0; 28 } 29 30 index_mask = SSIT_size - 1; 31 32 offset_bits = 2; 33} 34 35void 36StoreSet::violation(Addr store_PC, Addr load_PC) 37{ 38 int load_index = calcIndex(load_PC); 39 int store_index = calcIndex(store_PC); 40 41 assert(load_index < SSIT_size && store_index < SSIT_size); 42 43 bool valid_load_SSID = validSSIT[load_index]; 44 bool valid_store_SSID = validSSIT[store_index]; 45 46 if (!valid_load_SSID && !valid_store_SSID) { 47 // Calculate a new SSID here. 48 SSID new_set = calcSSID(load_PC); 49 50 validSSIT[load_index] = true; 51 52 SSIT[load_index] = new_set; 53 54 validSSIT[store_index] = true; 55 56 SSIT[store_index] = new_set; 57 58 assert(new_set < LFST_size); 59 60 SSCounters[new_set]++; 61 62 63 DPRINTF(StoreSet, "StoreSet: Neither load nor store had a valid " 64 "storeset, creating a new one: %i for load %#x, store %#x\n", 65 new_set, load_PC, store_PC); 66 } else if (valid_load_SSID && !valid_store_SSID) { 67 SSID load_SSID = SSIT[load_index]; 68 69 validSSIT[store_index] = true; 70 71 SSIT[store_index] = load_SSID; 72 73 assert(load_SSID < LFST_size); 74 75 SSCounters[load_SSID]++; 76 77 DPRINTF(StoreSet, "StoreSet: Load had a valid store set. Adding " 78 "store to that set: %i for load %#x, store %#x\n", 79 load_SSID, load_PC, store_PC); 80 } else if (!valid_load_SSID && valid_store_SSID) { 81 SSID store_SSID = SSIT[store_index]; 82 83 validSSIT[load_index] = true; 84 85 SSIT[load_index] = store_SSID; 86 87 // Because we are having a load point to an already existing set, 88 // the size of the store set is not incremented. 89 90 DPRINTF(StoreSet, "StoreSet: Store had a valid store set: %i for " 91 "load %#x, store %#x\n", 92 store_SSID, load_PC, store_PC); 93 } else { 94 SSID load_SSID = SSIT[load_index]; 95 SSID store_SSID = SSIT[store_index]; 96 97 assert(load_SSID < LFST_size && store_SSID < LFST_size); 98 99 int load_SS_size = SSCounters[load_SSID]; 100 int store_SS_size = SSCounters[store_SSID]; 101 102 // If the load has the bigger store set, then assign the store 103 // to the same store set as the load. Otherwise vice-versa. 104 if (load_SS_size > store_SS_size) { 105 SSIT[store_index] = load_SSID; 106 107 SSCounters[load_SSID]++; 108 SSCounters[store_SSID]--; 109 110 DPRINTF(StoreSet, "StoreSet: Load had bigger store set: %i; " 111 "for load %#x, store %#x\n", 112 load_SSID, load_PC, store_PC); 113 } else { 114 SSIT[load_index] = store_SSID; 115 116 SSCounters[store_SSID]++; 117 SSCounters[load_SSID]--; 118 119 DPRINTF(StoreSet, "StoreSet: Store had bigger store set: %i; " 120 "for load %#x, store %#x\n", 121 store_SSID, load_PC, store_PC); 122 } 123 } 124} 125 126void 127StoreSet::insertLoad(Addr load_PC, InstSeqNum load_seq_num) 128{ 129 // Does nothing. 130 return; 131} 132 133void 134StoreSet::insertStore(Addr store_PC, InstSeqNum store_seq_num) 135{ 136 int index = calcIndex(store_PC); 137 138 int store_SSID; 139 140 assert(index < SSIT_size); 141 142 if (!validSSIT[index]) { 143 // Do nothing if there's no valid entry. 144 return; 145 } else { 146 store_SSID = SSIT[index]; 147 148 assert(store_SSID < LFST_size); 149 150 // Update the last store that was fetched with the current one. 151 LFST[store_SSID] = store_seq_num; 152 153 validLFST[store_SSID] = 1; 154 155 DPRINTF(StoreSet, "Store %#x updated the LFST, SSID: %i\n", 156 store_PC, store_SSID); 157 } 158} 159 160InstSeqNum 161StoreSet::checkInst(Addr PC) 162{ 163 int index = calcIndex(PC); 164 165 int inst_SSID; 166 167 assert(index < SSIT_size); 168 169 if (!validSSIT[index]) { 170 DPRINTF(StoreSet, "Inst %#x with index %i had no SSID\n", 171 PC, index); 172 173 // Return 0 if there's no valid entry. 174 return 0; 175 } else { 176 inst_SSID = SSIT[index]; 177 178 assert(inst_SSID < LFST_size); 179 180 if (!validLFST[inst_SSID]) { 181 182 DPRINTF(StoreSet, "Inst %#x with index %i and SSID %i had no " 183 "dependency\n", PC, index, inst_SSID); 184 185 return 0; 186 } else { 187 DPRINTF(StoreSet, "Inst %#x with index %i and SSID %i had LFST " 188 "inum of %i\n", PC, index, inst_SSID, LFST[inst_SSID]); 189 190 return LFST[inst_SSID]; 191 } 192 } 193} 194 195void 196StoreSet::issued(Addr issued_PC, InstSeqNum issued_seq_num, bool is_store) 197{ 198 // This only is updated upon a store being issued. 199 if (!is_store) { 200 return; 201 } 202 203 int index = calcIndex(issued_PC); 204 205 int store_SSID; 206 207 assert(index < SSIT_size); 208 209 // Make sure the SSIT still has a valid entry for the issued store. 210 if (!validSSIT[index]) { 211 return; 212 } 213 214 store_SSID = SSIT[index]; 215 216 assert(store_SSID < LFST_size); 217 218 // If the last fetched store in the store set refers to the store that 219 // was just issued, then invalidate the entry. 220 if (validLFST[store_SSID] && LFST[store_SSID] == issued_seq_num) { 221 DPRINTF(StoreSet, "StoreSet: store invalidated itself in LFST.\n"); 222 validLFST[store_SSID] = false; 223 } 224} 225 226void 227StoreSet::squash(InstSeqNum squashed_num) 228{ 229 // Not really sure how to do this well. 230 // Generally this is small enough that it should be okay; short circuit 231 // evaluation should take care of invalid entries. 232 233 DPRINTF(StoreSet, "StoreSet: Squashing until inum %i\n", 234 squashed_num); 235 236 for (int i = 0; i < LFST_size; ++i) { 237 if (validLFST[i] && LFST[i] < squashed_num) { 238 validLFST[i] = false; 239 } 240 } 241} 242 243void 244StoreSet::clear() 245{ 246 for (int i = 0; i < SSIT_size; ++i) { 247 validSSIT[i] = false; 248 } 249 250 for (int i = 0; i < LFST_size; ++i) { 251 validLFST[i] = false; 252 } 253} 254 255