Changeset 4696
- Timestamp:
- Jul 24, 2015, 8:18:18 AM (4 years ago)
- Location:
- icGREP/icgrep-devel/icgrep/pablo
- Files:
-
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
icGREP/icgrep-devel/icgrep/pablo/carry_data.h
r4691 r4696 124 124 unsigned getLocalCarryPackIndex () { return shortAdvance.frameOffsetinBits / PACK_SIZE; } 125 125 126 unsigned getLocalCarry DataSize() { return fullOrPartialBlocks(nested.frameOffsetinBits - shortAdvance.frameOffsetinBits, PACK_SIZE); }126 unsigned getLocalCarryPackCount () { return fullOrPartialBlocks(nested.frameOffsetinBits - shortAdvance.frameOffsetinBits, PACK_SIZE); } 127 127 128 unsigned getScopeCarry DataSize() { return fullOrPartialBlocks(scopeCarryDataBits, PACK_SIZE); }128 unsigned getScopeCarryPackCount () { return fullOrPartialBlocks(scopeCarryDataBits, PACK_SIZE); } 129 129 130 130 bool blockHasCarries() const { return scopeCarryDataBits > 0;} -
icGREP/icgrep-devel/icgrep/pablo/carry_manager.cpp
r4694 r4696 45 45 mCarryPackPtr.resize(mTotalCarryDataBitBlocks); 46 46 mCarryInPack.resize(mTotalCarryDataBitBlocks); 47 mCarryInPhis.resize(mTotalCarryDataBitBlocks); 48 mCarryOutAccumPhis.resize(mTotalCarryDataBitBlocks); 49 mCarryOutVector.resize(mTotalCarryDataBitBlocks); 47 mCarryOutPack.resize(mTotalCarryDataBitBlocks); 50 48 for (auto i = 0; i < mTotalCarryDataBitBlocks; i++) mCarryInPack[i]=nullptr; 51 49 … … 89 87 if (cd->maxNestingDepth <= nestedBlockData->maxNestingDepth) cd->maxNestingDepth = nestedBlockData->maxNestingDepth + 1; 90 88 cd->nested.entries++; 89 #ifndef NDEBUG 90 nestedBlockData->dumpCarryData(cerr); 91 #endif 91 92 } 92 93 else if (While * whileStatement = dyn_cast<While>(stmt)) { … … 101 102 if (cd->maxNestingDepth <= nestedBlockData->maxNestingDepth) cd->maxNestingDepth = nestedBlockData->maxNestingDepth + 1; 102 103 cd->nested.entries++; 104 #ifndef NDEBUG 105 nestedBlockData->dumpCarryData(cerr); 106 #endif 103 107 } 104 108 } … … 118 122 cd->summary.allocatedBits = cd->scopeCarryDataBits; 119 123 } 120 #ifndef NDEBUG121 cd->dumpCarryData(cerr);122 #endif123 124 return cd->scopeCarryDataBits; 124 125 } … … 155 156 } 156 157 157 void CarryManager:: CarryPackStore(unsigned packIndex) {158 mBuilder->CreateAlignedStore(mCarryOut Vector[packIndex], mCarryPackPtr[packIndex], PACK_SIZE/8);159 } 160 161 Value * CarryManager::ge nCarryInRange(unsigned carryBit_lo, unsigned carryRangeSize) {158 void CarryManager::storeCarryPack(unsigned packIndex) { 159 mBuilder->CreateAlignedStore(mCarryOutPack[packIndex], mCarryPackPtr[packIndex], PACK_SIZE/8); 160 } 161 162 Value * CarryManager::getCarryRange(unsigned carryBit_lo, unsigned carryRangeSize) { 162 163 163 164 unsigned packIndex = carryBit_lo / PACK_SIZE; … … 175 176 } 176 177 177 178 Value * CarryManager::genCarryInBit(unsigned carryBitPos) { 179 return genCarryInRange(carryBitPos, 1); 180 } 181 /* Methods for getting and setting individual carry values. */ 182 183 //#define LOAD_STORE_ON_BLOCK_ENTRY_EXIT 178 Value * CarryManager::getCarryBit(unsigned carryBitPos) { 179 return getCarryRange(carryBitPos, 1); 180 } 181 182 void CarryManager::setCarryBits(unsigned carryBit_lo, Value * bits) { 183 184 unsigned packIndex = carryBit_lo / PACK_SIZE; 185 unsigned carryOffset = carryBit_lo % PACK_SIZE; 186 if (carryOffset > 0) { 187 bits = mBuilder->CreateLShr(bits, mBuilder->getInt64(carryOffset)); 188 } 189 if (mCarryOutPack[packIndex] == nullptr) { 190 mCarryOutPack[packIndex] = bits; 191 } 192 else { 193 mCarryOutPack[packIndex] = mBuilder->CreateOr(mCarryOutPack[packIndex], bits); 194 } 195 } 196 197 198 /* Methods for getting and setting individual carry values. */ 199 184 200 Value * CarryManager::getCarryOpCarryIn(int localIndex) { 185 201 unsigned cd_index = mCurrentFrameIndex + mCarryInfo->carryOpCarryDataOffset(localIndex); 202 #ifdef PACKING 203 return getCarryBit(cd_index); 204 #else 186 205 return getCarryPack(cd_index); 187 } 188 206 #endif 207 } 208 209 189 210 void CarryManager::setCarryOpCarryOut(unsigned localIndex, Value * carry_out) { 211 #ifdef PACKING 212 #else 190 213 unsigned cd_index = mCurrentFrameIndex + mCarryInfo->carryOpCarryDataOffset(localIndex); 191 mCarryOutVector[cd_index] = carry_out; 192 #ifndef LOAD_STORE_ON_BLOCK_ENTRY_EXIT 214 mCarryOutPack[cd_index] = carry_out; 193 215 if (mCarryInfo->getWhileDepth() == 0) { 194 CarryPackStore(cd_index);216 storeCarryPack(cd_index); 195 217 } 196 218 #endif … … 211 233 212 234 Value * CarryManager::unitAdvanceCarryInCarryOut(int localIndex, Value * strm) { 235 #ifdef PACKING 236 #else 213 237 214 238 unsigned carryDataIndex = mCurrentFrameIndex + mCarryInfo->unitAdvanceCarryDataOffset(localIndex); 215 mCarryOut Vector[carryDataIndex] = strm;239 mCarryOutPack[carryDataIndex] = strm; 216 240 Value * carry_in = getCarryPack(carryDataIndex); 217 #ifndef LOAD_STORE_ON_BLOCK_ENTRY_EXIT218 241 if (mCarryInfo->getWhileDepth() == 0) { 219 CarryPackStore(carryDataIndex); 220 } 221 #endif 242 storeCarryPack(carryDataIndex); 243 } 222 244 Value* result_value; 223 245 … … 233 255 #endif 234 256 return result_value; 257 #endif 235 258 } 236 259 237 260 Value * CarryManager::shortAdvanceCarryInCarryOut(int localIndex, int shift_amount, Value * strm) { 261 #ifdef PACKING 262 #else 238 263 unsigned carryDataIndex = mCurrentFrameIndex + mCarryInfo->shortAdvanceCarryDataOffset(localIndex); 239 mCarryOut Vector[carryDataIndex] = strm;264 mCarryOutPack[carryDataIndex] = strm; 240 265 Value * carry_in = getCarryPack(carryDataIndex); 241 #ifndef LOAD_STORE_ON_BLOCK_ENTRY_EXIT242 266 if (mCarryInfo->getWhileDepth() == 0) { 243 CarryPackStore(carryDataIndex); 244 } 245 #endif 267 storeCarryPack(carryDataIndex); 268 } 246 269 Value* advanceq_longint = mBuilder->CreateBitCast(carry_in, mBuilder->getIntNTy(BLOCK_SIZE)); 247 270 Value* strm_longint = mBuilder->CreateBitCast(strm, mBuilder->getIntNTy(BLOCK_SIZE)); 248 271 Value* adv_longint = mBuilder->CreateOr(mBuilder->CreateShl(strm_longint, shift_amount), mBuilder->CreateLShr(advanceq_longint, BLOCK_SIZE - shift_amount), "advance"); 249 272 return mBuilder->CreateBitCast(adv_longint, mBitBlockType); 273 #endif 250 274 } 251 275 … … 315 339 316 340 Value * CarryManager::getCarrySummaryExpr() { 341 #ifdef PACKING 342 #else 317 343 unsigned summary_idx = mCurrentFrameIndex + mCarryInfo->summaryCarryDataIndex(); 318 344 return getCarryPack(summary_idx); 345 #endif 319 346 } 320 347 … … 328 355 PHINode * summary_phi = mBuilder->CreatePHI(mBitBlockType, 2, "summary"); 329 356 summary_phi->addIncoming(mZeroInitializer, ifEntryBlock); 330 summary_phi->addIncoming(mCarryOut Vector[carrySummaryIndex], ifBodyFinalBlock);331 mCarryOut Vector[carrySummaryIndex] = summary_phi;357 summary_phi->addIncoming(mCarryOutPack[carrySummaryIndex], ifBodyFinalBlock); 358 mCarryOutPack[carrySummaryIndex] = summary_phi; 332 359 } 333 360 … … 350 377 else { 351 378 auto localCarryIndex = mCurrentFrameIndex + mCarryInfo->getLocalCarryPackIndex(); 352 auto localCarryPacks = mCarryInfo->getLocalCarry DataSize();379 auto localCarryPacks = mCarryInfo->getLocalCarryPackCount(); 353 380 if (localCarryPacks > 0) { 354 carry_summary = mCarryOut Vector[localCarryIndex];381 carry_summary = mCarryOutPack[localCarryIndex]; 355 382 for (auto i = 1; i < localCarryPacks; i++) { 356 383 //carry_summary = mBuilder->CreateOr(carry_summary, mPabloBlock->mCarryOutPack[i]); 357 carry_summary = mBuilder->CreateOr(carry_summary, mCarryOut Vector[localCarryIndex+i]);384 carry_summary = mBuilder->CreateOr(carry_summary, mCarryOutPack[localCarryIndex+i]); 358 385 } 359 386 } … … 363 390 enterScope(inner_blk); 364 391 if (blockHasCarries()) { 365 carry_summary = mBuilder->CreateOr(carry_summary, mCarryOut Vector[mCurrentFrameIndex + mCarryInfo->summaryCarryDataIndex()]);392 carry_summary = mBuilder->CreateOr(carry_summary, mCarryOutPack[mCurrentFrameIndex + mCarryInfo->summaryCarryDataIndex()]); 366 393 } 367 394 leaveScope(); … … 371 398 enterScope(inner_blk); 372 399 if (blockHasCarries()) { 373 carry_summary = mBuilder->CreateOr(carry_summary, mCarryOut Vector[mCurrentFrameIndex + mCarryInfo->summaryCarryDataIndex()]);400 carry_summary = mBuilder->CreateOr(carry_summary, mCarryOutPack[mCurrentFrameIndex + mCarryInfo->summaryCarryDataIndex()]); 374 401 } 375 402 leaveScope(); … … 379 406 // Calculation of the carry out summary is complete. Store it and make it 380 407 // available in case it must included by parent blocks. 381 mCarryOutVector[carrySummaryIndex] = carry_summary; 382 CarryPackStore(carrySummaryIndex); 383 } 384 385 386 void CarryManager::ensureCarriesLoadedLocal() { 387 #ifdef LOAD_STORE_ON_BLOCK_ENTRY_EXIT 388 if ((mCarryInfo->getScopeCarryDataSize() == 0 ) || (mCarryInfo->getWhileDepth() > 0)) return; 389 if ((mCarryInfo->getIfDepth() == 0) || mCarryInfo->explicitSummaryRequired()) { 390 auto localCarryIndex = mCurrentFrameIndex + mCarryInfo->getLocalCarryPackIndex(); 391 auto localCarryPacks = mCarryInfo->getLocalCarryDataSize(); 392 //std::cerr << "ensureCarriesLoadedLocal: localCarryIndex = " << localCarryIndex << "localCarryPacks = " << localCarryPacks << std::endl; 393 for (auto i = localCarryIndex; i < localCarryIndex + localCarryPacks; i++) { 394 mCarryInPack[i] = mBuilder->CreateAlignedLoad(mBuilder->CreateGEP(mCarryDataPtr, mBuilder->getInt64(i)), BLOCK_SIZE/8, false); 395 } 396 } 397 #endif 398 } 399 400 void CarryManager::ensureCarriesStoredLocal() { 401 #ifdef LOAD_STORE_ON_BLOCK_ENTRY_EXIT 402 if ((mCarryInfo->getScopeCarryDataSize() == 0 ) || (mCarryInfo->getWhileDepth() > 0)) return; 403 auto localCarryIndex = mCurrentFrameIndex + mCarryInfo->getLocalCarryPackIndex(); 404 auto localCarryPacks = mCarryInfo->getLocalCarryDataSize(); 405 //std::cerr << "ensureCarriesStoredLocal: localCarryIndex = " << localCarryIndex << "localCarryPacks = " << localCarryPacks << std::endl; 406 for (auto i = localCarryIndex; i < localCarryIndex + localCarryPacks; i++) { 407 Value * storePtr = mBuilder->CreateGEP(mCarryDataPtr, mBuilder->getInt64(i)); 408 mBuilder->CreateAlignedStore(mCarryOutVector[i], storePtr, BLOCK_SIZE/8, false); 409 } 410 #endif 408 mCarryOutPack[carrySummaryIndex] = carry_summary; 409 storeCarryPack(carrySummaryIndex); 411 410 } 412 411 … … 414 413 415 414 void CarryManager::ensureCarriesLoadedRecursive() { 416 const unsigned scopeCarry DataSize = mCarryInfo->getScopeCarryDataSize();415 const unsigned scopeCarryPacks = mCarryInfo->getScopeCarryPackCount(); 417 416 if (mCarryInfo->getWhileDepth() == 1) { 418 for (auto i = mCurrentFrameIndex; i < mCurrentFrameIndex + scopeCarry DataSize; ++i) {417 for (auto i = mCurrentFrameIndex; i < mCurrentFrameIndex + scopeCarryPacks; ++i) { 419 418 getCarryPack(i); 420 419 } … … 424 423 425 424 void CarryManager::initializeCarryDataPhisAtWhileEntry(BasicBlock * whileEntryBlock) { 426 const unsigned scopeCarryDataSize = mCarryInfo->getScopeCarryDataSize(); 427 for (unsigned index = mCurrentFrameIndex; index < mCurrentFrameIndex + scopeCarryDataSize; ++index) { 425 const unsigned scopeCarryPacks = mCarryInfo->getScopeCarryPackCount(); 426 mCarryOutAccumPhis.resize(scopeCarryPacks); 427 #ifdef SET_WHILE_CARRY_IN_TO_ZERO_AFTER_FIRST_ITERATION 428 mCarryInPhis.resize(scopeCarryPacks); 429 #endif 430 for (unsigned index = 0; index < scopeCarryPacks; ++index) { 428 431 #ifdef SET_WHILE_CARRY_IN_TO_ZERO_AFTER_FIRST_ITERATION 429 432 PHINode * phi_in = mBuilder->CreatePHI(mBitBlockType, 2); 430 phi_in->addIncoming(mCarryInPack[ index], whileEntryBlock);433 phi_in->addIncoming(mCarryInPack[mCurrentFrameIndex+index], whileEntryBlock); 431 434 mCarryInPhis[index] = phi_in; 432 435 #endif … … 439 442 440 443 void CarryManager::extendCarryDataPhisAtWhileBodyFinalBlock(BasicBlock * whileBodyFinalBlock) { 441 const unsigned scopeCarry DataSize = mCarryInfo->getScopeCarryDataSize();442 for (unsigned index = mCurrentFrameIndex; index < mCurrentFrameIndex + scopeCarryDataSize; ++index) {444 const unsigned scopeCarryPacks = mCarryInfo->getScopeCarryPackCount(); 445 for (unsigned index = 0; index < scopeCarryPacks; ++index) { 443 446 #ifdef SET_WHILE_CARRY_IN_TO_ZERO_AFTER_FIRST_ITERATION 444 447 mCarryInPhis[index]->addIncoming(mZeroInitializer, whileBodyFinalBlock); 445 448 #endif 446 449 PHINode * phi = mCarryOutAccumPhis[index]; 447 assert (phi); 448 assert (mCarryOutVector[index]); 449 Value * carryOut = mBuilder->CreateOr(phi, mCarryOutVector[index]); 450 Value * carryOut = mBuilder->CreateOr(phi, mCarryOutPack[mCurrentFrameIndex+index]); 450 451 phi->addIncoming(carryOut, whileBodyFinalBlock); 451 mCarryOut Vector[index] = carryOut;452 mCarryOutPack[mCurrentFrameIndex+index] = carryOut; 452 453 } 453 454 } 454 455 455 456 void CarryManager::ensureCarriesStoredRecursive() { 456 const unsigned scopeCarry DataSize = mCarryInfo->getScopeCarryDataSize();457 const unsigned scopeCarryPacks = mCarryInfo->getScopeCarryPackCount(); 457 458 if (mCarryInfo->getWhileDepth() == 1) { 458 for (auto i = mCurrentFrameIndex; i < mCurrentFrameIndex + scopeCarry DataSize; ++i) {459 CarryPackStore(i);460 } 461 } 462 } 463 464 } 465 459 for (auto i = mCurrentFrameIndex; i < mCurrentFrameIndex + scopeCarryPacks; ++i) { 460 storeCarryPack(i); 461 } 462 } 463 } 464 465 } 466 -
icGREP/icgrep-devel/icgrep/pablo/carry_manager.h
r4694 r4696 60 60 unsigned enumerate(PabloBlock * blk, unsigned ifDepth, unsigned whileDepth); 61 61 62 void generateBlockNoIncrement(); 63 62 void generateBlockNoIncrement(); 64 63 Value * getBlockNoPtr(); 65 64 … … 67 66 68 67 void enterScope(PabloBlock * blk); 69 70 68 void leaveScope(); 71 69 72 /* Helper routines */73 74 75 Value * getCarryPack(unsigned packIndex);76 77 void CarryPackStore(unsigned packIndex);78 79 Value * genCarryInRange(unsigned carryBit_lo, unsigned carryRangeSize);80 81 Value * genCarryInBit(unsigned carryBitPos);82 83 70 /* Methods for processing individual carry-generating operations. */ 84 71 85 72 Value * getCarryOpCarryIn(int localIndex); 86 87 73 void setCarryOpCarryOut(unsigned idx, Value * carry_out); 88 74 … … 98 84 99 85 void addSummaryPhiIfNeeded(BasicBlock * ifEntryBlock, BasicBlock * ifBodyFinalBlock); 100 101 /* Methods for load/store of carries for non-while blocks. */102 103 void ensureCarriesLoadedLocal();104 105 void ensureCarriesStoredLocal();106 86 107 87 /* Methods for handling while statements */ … … 141 121 std::vector<PHINode *> mCarryInPhis; 142 122 std::vector<PHINode *> mCarryOutAccumPhis; 143 std::vector<Value *> mCarryOut Vector;123 std::vector<Value *> mCarryOutPack; 144 124 145 125 Value * unitAdvanceCarryInCarryOut(int localIndex, Value * strm); 146 126 Value * shortAdvanceCarryInCarryOut(int localIndex, int shift_amount, Value * strm); 147 127 Value * longAdvanceCarryInCarryOut(int localIndex, int shift_amount, Value * strm); 128 129 130 /* Helper routines */ 131 Value * getCarryPack(unsigned packIndex); 132 void storeCarryPack(unsigned packIndex); 133 134 Value * getCarryRange(unsigned carryBit_lo, unsigned carryRangeSize); 135 Value * getCarryBit(unsigned carryBitPos); 136 void setCarryBits(unsigned carryBit_lo, Value * bits); 137 138 148 139 149 140 }; -
icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp
r4692 r4696 356 356 void PabloCompiler::compileBlock(PabloBlock & block) { 357 357 mPabloBlock = & block; 358 mCarryManager->ensureCarriesLoadedLocal();359 358 for (const Statement * statement : block) { 360 359 compileStatement(statement); 361 360 } 362 mCarryManager->ensureCarriesStoredLocal();363 361 mPabloBlock = block.getParent(); 364 362 }
Note: See TracChangeset
for help on using the changeset viewer.