Ignore:
Timestamp:
Feb 17, 2018, 12:50:34 PM (14 months ago)
Author:
xwa163
Message:
  1. Implement LZ4MultiplePdepKernel, which can do PDEP for more than one input streamset
  2. Add attributed Swizzled in StreamSet?, copy at least one whole block when doing temporary buffer copy for Swizzled InputStreamSet?
  3. Bug fixing for character_deposit pipeline
  4. Add more test files for character_deposit pipeline
File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/kernels/kernel.cpp

    r5865 r5873  
    707707                ub += RateValue(input.getLookahead(), mStride);
    708708            }
    709             Constant * const arraySize = b->getInt64(ceiling(ub));
     709            Value * arraySize = b->getInt64(ceiling(ub));
     710
     711            auto name = input.getName();
     712            if (input.isSwizzled()) {
     713                // TODO workaround to use larger temporary buffer size for swizzled buffer
     714                arraySize = b->CreateMul(arraySize, b->getSize(codegen::BufferSegments * codegen::ThreadNum * codegen::SegmentSize));
     715            }
     716
    710717            AllocaInst * const ptr = b->CreateAlignedAlloca(ty, blockAlignment, arraySize);
    711718            assert (ptr->isStaticAlloca());
     
    834841
    835842            BasicBlock * const entry = b->GetInsertBlock();
    836             BasicBlock * const copyFromBack = b->CreateBasicBlock(name + "CopyFromBack");
    837             BasicBlock * const copyFromFront = b->CreateBasicBlock(name + "CopyFromFront");
    838             BasicBlock * const resume = b->CreateBasicBlock(name + "Resume");
    839843
    840844            Value * strideSize = inputStrideSize[i];
     
    843847                strideSize = b->CreateAdd(strideSize, lookahead);
    844848            }
     849
    845850            Value * const requiresCopy = b->CreateICmpULT(accessible, strideSize);
    846             b->CreateUnlikelyCondBr(requiresCopy, copyFromBack, resume);
    847 
    848             b->SetInsertPoint(copyFromBack);
    849             Value * const arraySize = b->CreateZExt(tempBuffer->getArraySize(), b->getInt64Ty());
    850             Value * const temporarySize = b->CreateTrunc(b->CreateMul(arraySize, b->getInt64(mStride)), accessible->getType());
    851             Value * const copyable = b->CreateUMin(unprocessed, temporarySize); // <- we only really need strideSize items
    852             Value * const offset = b->CreateAnd(processed, BLOCK_WIDTH_MASK);
    853             Value * const bufferSize = b->CreateMul(ConstantExpr::getSizeOf(tempBuffer->getAllocatedType()), arraySize);
    854             b->CreateMemZero(tempBuffer, bufferSize, blockAlignment);
    855             b->CreateStreamCpy(name, tempBuffer, ZERO, mStreamSetInputBaseAddress[i], offset, accessible, getItemAlignment(input));
    856             BasicBlock * const copyToBackEnd = b->GetInsertBlock();
    857             b->CreateCondBr(b->CreateICmpNE(copyable, accessible), copyFromFront, resume);
    858 
    859             b->SetInsertPoint(copyFromFront);
    860             Value * const remaining = b->CreateSub(copyable, accessible);
    861             Value * const baseAddress = b->getBaseAddress(name);
    862             b->CreateStreamCpy(name, tempBuffer, accessible, baseAddress, ZERO, remaining, getItemAlignment(input));
    863             Value * const isPartialStride = b->CreateICmpUGE(copyable, strideSize);
    864             BasicBlock * const copyToFrontEnd = b->GetInsertBlock();
    865             b->CreateBr(resume);
     851
     852            BasicBlock * const resume = b->CreateBasicBlock(name + "Resume");
     853
     854            BasicBlock * copyToBackEnd = NULL;
     855            BasicBlock * copyToFrontEnd = NULL;
     856            Value * isPartialStride = NULL;
     857            Value * newAvailable = NULL;
     858
     859            if (input.isSwizzled()) {
     860                // Copy at least one whole block for Swizzled input stream
     861                BasicBlock * const copyFromBack = b->CreateBasicBlock(name + "CopyFromBack");
     862                BasicBlock * const copyFromFront = b->CreateBasicBlock(name + "CopyFromFront");
     863
     864                b->CreateUnlikelyCondBr(requiresCopy, copyFromBack, resume);
     865
     866                b->SetInsertPoint(copyFromBack);
     867
     868
     869                Value * const arraySize = b->CreateZExt(tempBuffer->getArraySize(), b->getInt64Ty());
     870                Value * const temporarySize = b->CreateTrunc(b->CreateMul(arraySize, b->getInt64(mStride)), accessible->getType());
     871
     872                Value * const processedOffset = b->CreateAnd(processed, BLOCK_WIDTH_MASK);
     873                Value * const copyable = b->CreateUMin(b->CreateAdd(unprocessed, processedOffset), temporarySize); // <- we only really need strideSize items
     874                newAvailable = b->CreateSub(copyable, processedOffset);
     875//                b->CallPrintInt("newAvailable", newAvailable);
     876
     877                Value * const bufferSize = b->CreateMul(ConstantExpr::getSizeOf(tempBuffer->getAllocatedType()), arraySize);
     878                b->CreateMemZero(tempBuffer, bufferSize, blockAlignment);
     879
     880//                b->CallPrintInt("temporarySize", temporarySize);
     881//                b->CallPrintInt("processed", processed);
     882//                b->CallPrintInt("unprocessed", unprocessed);
     883//                b->CallPrintInt("processedOffset", processedOffset);
     884//                b->CallPrintInt("copyable", copyable);
     885
     886//                b->CallPrintInt("streamCpy1", b->getSize(0));
     887                Value* BIT_BLOCK_WIDTH = b->getSize(b->getBitBlockWidth());
     888
     889                Value* copyAmount1 = b->CreateAdd(accessible, processedOffset);
     890                Value* roundCopyAmount = b->CreateMul(b->CreateUDivCeil(copyAmount1, BIT_BLOCK_WIDTH), BIT_BLOCK_WIDTH);
     891                b->CreateStreamCpy(name, tempBuffer, ZERO, mStreamSetInputBaseAddress[i], ZERO, roundCopyAmount, getItemAlignment(input));
     892
     893                copyToBackEnd = b->GetInsertBlock();
     894
     895                b->CreateCondBr(b->CreateICmpNE(copyable, b->CreateAdd(accessible, processedOffset)), copyFromFront, resume);
     896
     897                b->SetInsertPoint(copyFromFront);
     898                Value * const remaining = b->CreateSub(copyable, b->CreateAdd(accessible, processedOffset));
     899                Value * const baseAddress = b->getBaseAddress(name);
     900//                b->CallPrintInt("streamCpy2", b->getSize(0));
     901
     902                auto castedTempBuffer = b->CreatePointerCast(tempBuffer, b->getBitBlockType()->getPointerTo());
     903
     904                auto p = b->CreateGEP(
     905                        castedTempBuffer,
     906                        b->CreateMul(
     907                                b->CreateUDiv(b->CreateAdd(accessible, processedOffset), BIT_BLOCK_WIDTH),
     908                                b->getSize(this->getAnyStreamSetBuffer(name)->getNumOfStreams())
     909                        )
     910                );
     911//                b->CreateStreamCpy(name, tempBuffer, b->CreateAdd(accessible, processedOffset), baseAddress, ZERO, remaining, getItemAlignment(input));
     912
     913
     914                b->CreateStreamCpy(name, p, ZERO, baseAddress, ZERO, b->CreateMul(b->CreateUDivCeil(remaining, BIT_BLOCK_WIDTH), BIT_BLOCK_WIDTH), getItemAlignment(input));
     915                isPartialStride = b->CreateICmpUGE(copyable, strideSize);
     916                copyToFrontEnd = b->GetInsertBlock();
     917
     918
     919
     920                b->CreateBr(resume);
     921            } else {
     922                BasicBlock * const copyFromBack = b->CreateBasicBlock(name + "CopyFromBack");
     923                BasicBlock * const copyFromFront = b->CreateBasicBlock(name + "CopyFromFront");
     924
     925                b->CreateUnlikelyCondBr(requiresCopy, copyFromBack, resume);
     926
     927                b->SetInsertPoint(copyFromBack);
     928                Value * const arraySize = b->CreateZExt(tempBuffer->getArraySize(), b->getInt64Ty());
     929                Value * const temporarySize = b->CreateTrunc(b->CreateMul(arraySize, b->getInt64(mStride)), accessible->getType());
     930                Value * const copyable = b->CreateUMin(unprocessed, temporarySize); // <- we only really need strideSize items
     931                newAvailable = copyable;
     932                Value * const offset = b->CreateAnd(processed, BLOCK_WIDTH_MASK);
     933
     934                Value * const bufferSize = b->CreateMul(ConstantExpr::getSizeOf(tempBuffer->getAllocatedType()), arraySize);
     935                b->CreateMemZero(tempBuffer, bufferSize, blockAlignment);
     936
     937                b->CreateStreamCpy(name, tempBuffer, ZERO, mStreamSetInputBaseAddress[i], offset, accessible, getItemAlignment(input));
     938//            b->CallPrintInt("gep", b->CreateGEP(mStreamSetInputBaseAddress[i], b->CreateUDiv(offset, b->getSize(this->getAnyStreamSetBuffer(name)->getNumOfStreams()))));
     939//            b->CallPrintRegister(name + "_tempBuffer", b->CreateLoad(tempBuffer));
     940                copyToBackEnd = b->GetInsertBlock();
     941                b->CreateCondBr(b->CreateICmpNE(copyable, accessible), copyFromFront, resume);
     942
     943                b->SetInsertPoint(copyFromFront);
     944                Value * const remaining = b->CreateSub(copyable, accessible);
     945                Value * const baseAddress = b->getBaseAddress(name);
     946                b->CreateStreamCpy(name, tempBuffer, accessible, baseAddress, ZERO, remaining, getItemAlignment(input));
     947                isPartialStride = b->CreateICmpUGE(copyable, strideSize);
     948                copyToFrontEnd = b->GetInsertBlock();
     949                b->CreateBr(resume);
     950            }
    866951
    867952            b->SetInsertPoint(resume);
     
    873958            PHINode * const available = b->CreatePHI(accessible->getType(), 3);
    874959            available->addIncoming(accessible, entry);
    875             available->addIncoming(copyable, copyToBackEnd);
    876             available->addIncoming(copyable, copyToFrontEnd);
     960            available->addIncoming(newAvailable, copyToBackEnd);
     961            available->addIncoming(newAvailable, copyToFrontEnd);
    877962            linearlyCopyable[i] = available;
    878963            PHINode * const finalStride = b->CreatePHI(b->getInt1Ty(), 3);
Note: See TracChangeset for help on using the changeset viewer.