Changeset 6070


Ignore:
Timestamp:
Jun 8, 2018, 1:03:34 AM (13 days ago)
Author:
xwa163
Message:

Improve performance of literal copy and match copy in LZ4ParallelByteSteamAIOKernel

Location:
icGREP/icgrep-devel/icgrep
Files:
4 edited

Legend:

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

    r6066 r6070  
    1 //
    2 // Created by wxy325 on 2018/5/31.
    3 //
    41
    52#include "lz4_parallel_bytestream_aio.h"
     
    2017namespace kernel{
    2118
    22     LZ4ParallelByteStreamAioKernel::LZ4ParallelByteStreamAioKernel(const std::unique_ptr<kernel::KernelBuilder> &b)
     19    LZ4ParallelByteStreamAioKernel::LZ4ParallelByteStreamAioKernel(const std::unique_ptr<kernel::KernelBuilder> &b, size_t outputBlockSize)
    2320            :SegmentOrientedKernel("LZ4ParallelByteStreamAioKernel",
    2421            // Inputs
    2522                                   {
    2623                    Binding{b->getStreamSetTy(1, 8), "byteStream", BoundedRate(0, 1)},
    27                     Binding{b->getStreamSetTy(1, 1), "extender", RateEqualTo("byteStream")},
    2824
    2925                    // block data
     
    4743                                           Binding{b->getIntNTy(SIMD_WIDTH), "outputPos"},
    4844
    49                                    }){
     45                                   }), mOutputBlockSize(outputBlockSize) {
    5046        this->setStride(4 * 1024 * 1024 * 4);
    5147        addAttribute(MustExplicitlyTerminate());
     
    683679    }
    684680
    685 
    686     void LZ4ParallelByteStreamAioKernel::handleSimdMatchCopy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* matchOffsetVec, llvm::Value* matchLengthVec, llvm::Value* outputPosVec) {
    687         // TODO use memcpy first
    688 //        Value* l = b->CreateExtractElement(matchLengthVec, (uint64_t)0);
    689 //        Value* shouldPrint = b->CreateICmpNE(l, b->getSize(0));
    690 //        b->CallPrintIntCond("matchOffset", b->CreateExtractElement(matchOffsetVec, (uint64_t)0), shouldPrint);
    691 //        b->CallPrintIntCond("matchLength", l, shouldPrint);
     681    void LZ4ParallelByteStreamAioKernel::generateSimdMatchCopyByMemcpy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* matchOffsetVec, llvm::Value* matchLengthVec, llvm::Value* outputPosVec) {
    692682        Value* outputCapacity = b->getCapacity("outputStream");
    693683        Value* outputBasePtr = b->CreatePointerCast(b->getRawOutputPointer("outputStream", b->getSize(0)), b->getInt8PtrTy());
     
    703693            Value* initMatchLength = b->CreateExtractElement(matchLengthVec, i);
    704694            Value* initOutputPos = b->CreateExtractElement(outputPosVec, i);
    705 //            b->CreateLikelyCondBr(b->CreateICmpNE(matchOffset, b->getSize(0)), matchCopyConBlock, matchCopyExitBlock);
    706695            b->CreateBr(matchCopyConBlock);
    707696
     
    712701            PHINode* phiOutputPos = b->CreatePHI(initOutputPos->getType(), 2);
    713702            phiOutputPos->addIncoming(initOutputPos, beforeConBlock);
    714 //            b->CallPrintInt("phiMatchLength", phiMatchLength);
    715 //            b->CallPrintInt("matchOffset", matchOffset);
    716703
    717704            b->CreateCondBr(b->CreateICmpUGT(phiMatchLength, b->getSize(0)), matchCopyBodyBlock, matchCopyExitBlock);
     
    739726    }
    740727
     728    void LZ4ParallelByteStreamAioKernel::generateSimdSequentialMatchCopy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* matchOffsetVec, llvm::Value* matchLengthVec, llvm::Value* outputPosVec) {
     729
     730        // Constant
     731        Constant * SIZE_8 = b->getSize(8);
     732        // Type
     733        PointerType* i64PtrTy = b->getInt64Ty()->getPointerTo();
     734        PointerType* i8PtrTy = b->getInt8PtrTy();
     735
     736        Value* outputCapacity = b->getCapacity("outputStream");
     737        Value* outputPosRemVec = b->simd_and(outputPosVec, b->simd_fill(SIMD_WIDTH, b->CreateNot(b->CreateNeg(outputCapacity))));
     738        Value* outputPosRemBlockSizeVec = b->simd_and(outputPosVec, b->simd_fill(SIMD_WIDTH, b->CreateNot(b->CreateNeg(b->getIntN(SIMD_WIDTH, mOutputBlockSize)))));
     739        Value* remainingBlockSizeVec = b->simd_sub(SIMD_WIDTH, b->simd_fill(SIMD_WIDTH, b->getIntN(SIMD_WIDTH, mOutputBlockSize)), outputPosRemBlockSizeVec);
     740        Value* copyFromPosRemVec = b->simd_sub(SIMD_WIDTH, outputPosRemVec, matchOffsetVec);
     741
     742
     743        Value* outputBasePtr = b->CreatePointerCast(b->getRawOutputPointer("outputStream", b->getSize(0)), b->getInt8PtrTy());
     744
     745
     746        for (unsigned i = 0; i < b->getBitBlockWidth() / SIMD_WIDTH; i++) {
     747
     748            BasicBlock* exitBlock = b->CreateBasicBlock("exitBlock");
     749            BasicBlock* i64MatchCopyBlock = b->CreateBasicBlock("i64LiteralCopyBlock");
     750            BasicBlock* i8MatchCopyBlock = b->CreateBasicBlock("i8LiteralCopyBlock");
     751
     752            // ---- entryBlock
     753            Value* matchOffset = b->CreateExtractElement(matchOffsetVec, i);
     754            Value* matchLength = b->CreateExtractElement(matchLengthVec, i);
     755            Value* outputPosRem = b->CreateExtractElement(outputPosRemVec, i);
     756            Value* remainingBlockSize = b->CreateExtractElement(remainingBlockSizeVec, i);
     757            Value* outputFromRem = b->CreateExtractElement(copyFromPosRemVec, i);
     758
     759            Value* inputInitPtr = b->CreateGEP(outputBasePtr, outputFromRem);
     760            Value* outputInitPtr = b->CreateGEP(outputBasePtr, outputPosRem);
     761
     762            b->CreateLikelyCondBr(b->CreateICmpUGE(b->CreateSub(remainingBlockSize, matchLength), SIZE_8), i64MatchCopyBlock, i8MatchCopyBlock);
     763
     764            //// i64 Match Copy
     765            // ---- i64MatchCopyBlock
     766            b->SetInsertPoint(i64MatchCopyBlock);
     767
     768            this->generateOverwritingMemcpy(b, inputInitPtr, outputInitPtr, matchLength, i64PtrTy, b->CreateUMin(matchOffset, SIZE_8));
     769            b->CreateBr(exitBlock);
     770
     771            //// i8 Match Copy
     772            // ---- i8MatchCopyBlock
     773            b->SetInsertPoint(i8MatchCopyBlock);
     774            this->generateOverwritingMemcpy(b, inputInitPtr, outputInitPtr, matchLength, i8PtrTy, 1);
     775            b->CreateBr(exitBlock);
     776
     777            // ---- exitBlock
     778            b->SetInsertPoint(exitBlock);
     779
     780        }
     781
     782    }
     783
     784    void LZ4ParallelByteStreamAioKernel::handleSimdMatchCopy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* matchOffsetVec, llvm::Value* matchLengthVec, llvm::Value* outputPosVec) {
     785//        this->generateSimdMatchCopyByMemcpy(b, matchOffsetVec, matchLengthVec, outputPosVec);
     786        this->generateSimdSequentialMatchCopy(b, matchOffsetVec, matchLengthVec, outputPosVec);
     787    }
     788
    741789    void LZ4ParallelByteStreamAioKernel::handleSimdLiteralCopy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* literalStartVec, llvm::Value* literalLengthVec, llvm::Value* outputPosVec) {
     790        this->generateSimdSequentialLiteralCopy(b, literalStartVec, literalLengthVec, outputPosVec);
     791//        this->generateSequentialLiteralCopyWithSimdCalculation(b, literalStartVec, literalLengthVec, outputPosVec);
     792//        this->generateLiteralCopyByMemcpy(b, literalStartVec, literalLengthVec, outputPosVec);
     793    }
     794
     795    void LZ4ParallelByteStreamAioKernel::generateSimdLiteralCopyByMemcpy(const std::unique_ptr<KernelBuilder> &b,
     796                                                                         llvm::Value *literalStartVec,
     797                                                                         llvm::Value *literalLengthVec,
     798                                                                         llvm::Value *outputPosVec) {
     799        // This function will be slower than other literal copy related function, it is only for performance testing.
    742800        Value* outputCapacity = b->getCapacity("outputStream");
    743801        Value* outputPosRemVec = b->simd_and(outputPosVec, b->simd_fill(SIMD_WIDTH, b->simd_not(b->CreateNeg(outputCapacity))));
    744         // TODO use memcpy first
    745802
    746803        Value* inputBasePtr = b->CreatePointerCast(b->getRawInputPointer("byteStream", b->getSize(0)), b->getInt8PtrTy());
     
    758815            );
    759816        }
    760 
     817    }
     818
     819    void LZ4ParallelByteStreamAioKernel::generateSimdSequentialLiteralCopy(const std::unique_ptr<KernelBuilder> &b,
     820                                                                           llvm::Value *literalStartVec,
     821                                                                           llvm::Value *literalLengthVec,
     822                                                                           llvm::Value *outputPosVec) {
     823        // Constant
     824        Constant * SIZE_8 = b->getSize(8);
     825        // Type
     826        PointerType* i64PtrTy = b->getInt64Ty()->getPointerTo();
     827        PointerType* i8PtrTy = b->getInt8PtrTy();
     828
     829        Value* outputCapacity = b->getCapacity("outputStream");
     830        Value* outputPosRemVec = b->simd_and(outputPosVec, b->simd_fill(SIMD_WIDTH, b->CreateNot(b->CreateNeg(outputCapacity))));
     831        Value* outputPosRemBlockSizeVec = b->simd_and(outputPosVec, b->simd_fill(SIMD_WIDTH, b->CreateNot(b->CreateNeg(b->getIntN(SIMD_WIDTH, mOutputBlockSize)))));
     832        Value* remainingBlockSizeVec = b->simd_sub(SIMD_WIDTH, b->simd_fill(SIMD_WIDTH, b->getIntN(SIMD_WIDTH, mOutputBlockSize)), outputPosRemBlockSizeVec);
     833
     834        Value* inputBasePtr = b->CreatePointerCast(b->getRawInputPointer("byteStream", b->getSize(0)), b->getInt8PtrTy());
     835        Value* outputBasePtr = b->CreatePointerCast(b->getRawOutputPointer("outputStream", b->getSize(0)), b->getInt8PtrTy());
     836
     837
     838        for (unsigned i = 0; i < b->getBitBlockWidth() / SIMD_WIDTH; i++) {
     839            BasicBlock* exitBlock = b->CreateBasicBlock("exitBlock");
     840            BasicBlock* i64LiteralCopyBlock = b->CreateBasicBlock("i64LiteralCopyBlock");
     841            BasicBlock* i8LiteralCopyBlock = b->CreateBasicBlock("i8LiteralCopyBlock");
     842
     843            // ---- entryBlock
     844            Value* literalStart = b->CreateExtractElement(literalStartVec, i);
     845            Value* literalLength = b->CreateExtractElement(literalLengthVec, i);
     846            Value* outputPosRem = b->CreateExtractElement(outputPosRemVec, i);
     847            Value* remainingBlockSize = b->CreateExtractElement(remainingBlockSizeVec, i);
     848
     849            Value* inputInitPtr = b->CreateGEP(inputBasePtr, literalStart);
     850            Value* outputInitPtr = b->CreateGEP(outputBasePtr, outputPosRem);
     851
     852            b->CreateLikelyCondBr(b->CreateICmpUGE(b->CreateSub(remainingBlockSize, literalLength), SIZE_8), i64LiteralCopyBlock, i8LiteralCopyBlock);
     853
     854            //// i64 Literal Copy
     855            // ---- i64LiteralCopyBlock
     856            b->SetInsertPoint(i64LiteralCopyBlock);
     857            this->generateOverwritingMemcpy(b, inputInitPtr, outputInitPtr, literalLength, i64PtrTy, 8);
     858            b->CreateBr(exitBlock);
     859
     860            //// i8 Literal Copy
     861            // ---- i8LiteralCopyBlock
     862            b->SetInsertPoint(i8LiteralCopyBlock);
     863            this->generateOverwritingMemcpy(b, inputInitPtr, outputInitPtr, literalLength, i8PtrTy, 1);
     864            b->CreateBr(exitBlock);
     865
     866            // ---- exitBlock
     867            b->SetInsertPoint(exitBlock);
     868        }
     869    }
     870    void LZ4ParallelByteStreamAioKernel::generateOverwritingMemcpy(const std::unique_ptr<KernelBuilder> &b, llvm::Value *inputBasePtr,
     871                                   llvm::Value *outputBasePtr, llvm::Value *copyBytes, llvm::PointerType *targetPtrTy,
     872                                   llvm::Value* stepSize) {
     873        unsigned targetPtrBitWidth = targetPtrTy->getElementType()->getIntegerBitWidth();
     874
     875        Constant * SIZE_0 = b->getSize(0);
     876        Constant * SIZE_1 = b->getSize(1);
     877        PointerType* i8PtrTy = b->getInt8PtrTy();
     878
     879        BasicBlock* entryBlock = b->GetInsertBlock();
     880        BasicBlock* exitBlock = b->CreateBasicBlock("exitBlock");
     881        BasicBlock* conBlock = b->CreateBasicBlock("conBlock");
     882        BasicBlock* bodyBlock = b->CreateBasicBlock("bodyBlock");
     883
     884        Value* inputInitPtr = b->CreatePointerCast(inputBasePtr, targetPtrTy);
     885        Value* outputInitPtr = b->CreatePointerCast(outputBasePtr, targetPtrTy);
     886
     887        b->CreateBr(conBlock);
     888        // ---- conBlock
     889        b->SetInsertPoint(conBlock);
     890
     891        PHINode *phiCopiedSize = b->CreatePHI(b->getSizeTy(), 2);
     892        phiCopiedSize->addIncoming(SIZE_0, entryBlock);
     893        PHINode *phiInputPtr = b->CreatePHI(targetPtrTy, 2);
     894        phiInputPtr->addIncoming(inputInitPtr, entryBlock);
     895        PHINode *phiOutputPtr = b->CreatePHI(targetPtrTy, 2);
     896        phiOutputPtr->addIncoming(outputInitPtr, entryBlock);
     897
     898        b->CreateCondBr(b->CreateICmpULT(phiCopiedSize, copyBytes), bodyBlock, exitBlock);
     899
     900        // ---- bodyBlock
     901        b->SetInsertPoint(bodyBlock);
     902        b->CreateStore(b->CreateLoad(phiInputPtr), phiOutputPtr);
     903
     904        phiCopiedSize->addIncoming(b->CreateAdd(phiCopiedSize, stepSize), b->GetInsertBlock());
     905
     906        Value *newInputPtr = nullptr, *newOutputPtr = nullptr;
     907
     908        newInputPtr = b->CreatePointerCast(
     909                b->CreateGEP(b->CreatePointerCast(phiInputPtr, i8PtrTy), stepSize),
     910                targetPtrTy
     911        );
     912
     913        newOutputPtr = b->CreatePointerCast(
     914                b->CreateGEP(b->CreatePointerCast(phiOutputPtr, i8PtrTy), stepSize),
     915                targetPtrTy
     916        );
     917
     918        phiInputPtr->addIncoming(newInputPtr, b->GetInsertBlock());
     919        phiOutputPtr->addIncoming(newOutputPtr, b->GetInsertBlock());
     920        b->CreateBr(conBlock);
     921
     922        // ---- exitBlock
     923        b->SetInsertPoint(exitBlock);
     924    }
     925
     926    void LZ4ParallelByteStreamAioKernel::generateOverwritingMemcpy(const std::unique_ptr<KernelBuilder> &b,
     927                                                                   llvm::Value *inputBasePtr,
     928                                                                   llvm::Value *outputBasePtr,
     929                                                                   llvm::Value *copyBytes, llvm::PointerType *targetPtrTy,
     930                                                                   size_t stepSize) {
     931        unsigned targetPtrBitWidth = targetPtrTy->getElementType()->getIntegerBitWidth();
     932
     933        Constant * SIZE_0 = b->getSize(0);
     934        Constant * SIZE_1 = b->getSize(1);
     935        PointerType* i8PtrTy = b->getInt8PtrTy();
     936
     937        BasicBlock* entryBlock = b->GetInsertBlock();
     938        BasicBlock* exitBlock = b->CreateBasicBlock("exitBlock");
     939        BasicBlock* conBlock = b->CreateBasicBlock("conBlock");
     940        BasicBlock* bodyBlock = b->CreateBasicBlock("bodyBlock");
     941
     942        Value* inputInitPtr = b->CreatePointerCast(inputBasePtr, targetPtrTy);
     943        Value* outputInitPtr = b->CreatePointerCast(outputBasePtr, targetPtrTy);
     944
     945        b->CreateBr(conBlock);
     946        // ---- conBlock
     947        b->SetInsertPoint(conBlock);
     948
     949        PHINode *phiCopiedSize = b->CreatePHI(b->getSizeTy(), 2);
     950        phiCopiedSize->addIncoming(SIZE_0, entryBlock);
     951        PHINode *phiInputPtr = b->CreatePHI(targetPtrTy, 2);
     952        phiInputPtr->addIncoming(inputInitPtr, entryBlock);
     953        PHINode *phiOutputPtr = b->CreatePHI(targetPtrTy, 2);
     954        phiOutputPtr->addIncoming(outputInitPtr, entryBlock);
     955
     956        b->CreateCondBr(b->CreateICmpULT(phiCopiedSize, copyBytes), bodyBlock, exitBlock);
     957
     958        // ---- bodyBlock
     959        b->SetInsertPoint(bodyBlock);
     960        b->CreateStore(b->CreateLoad(phiInputPtr), phiOutputPtr);
     961
     962        phiCopiedSize->addIncoming(b->CreateAdd(phiCopiedSize, b->getSize(stepSize)), b->GetInsertBlock());
     963
     964        Value *newInputPtr = nullptr, *newOutputPtr = nullptr;
     965
     966        if (targetPtrBitWidth / 8 == stepSize) {
     967            newInputPtr = b->CreateGEP(phiInputPtr, SIZE_1);
     968            newOutputPtr = b->CreateGEP(phiOutputPtr, SIZE_1);
     969        } else {
     970            newInputPtr = b->CreatePointerCast(
     971                    b->CreateGEP(b->CreatePointerCast(phiInputPtr, i8PtrTy), b->getSize(stepSize)),
     972                    targetPtrTy
     973            );
     974
     975            newOutputPtr = b->CreatePointerCast(
     976                    b->CreateGEP(b->CreatePointerCast(phiOutputPtr, i8PtrTy), b->getSize(stepSize)),
     977                    targetPtrTy
     978            );
     979
     980        }
     981
     982        phiInputPtr->addIncoming(newInputPtr, b->GetInsertBlock());
     983        phiOutputPtr->addIncoming(newOutputPtr, b->GetInsertBlock());
     984        b->CreateBr(conBlock);
     985
     986        // ---- exitBlock
     987        b->SetInsertPoint(exitBlock);
     988    }
     989
     990    void LZ4ParallelByteStreamAioKernel::generateSimdLiteralCopyByScatter(const std::unique_ptr<KernelBuilder> &b,
     991                                                                          llvm::Value *literalStartVec,
     992                                                                          llvm::Value *literalLengthVec,
     993                                                                          llvm::Value *outputPosVec) {
     994        // TODO
     995    }
     996
     997    void LZ4ParallelByteStreamAioKernel::generateSimdSequentialLiteralCopyWithSimdCalculation(
     998            const std::unique_ptr<KernelBuilder> &b, llvm::Value *literalStartVec, llvm::Value *literalLengthVec,
     999            llvm::Value *outputPosVec) {
     1000        // TODO Incomplete
     1001
     1002        /*
     1003        Value* outputCapacity = b->getCapacity("outputStream");
     1004        Value* outputPosRemVec = b->simd_and(outputPosVec, b->simd_fill(SIMD_WIDTH, b->CreateNot(b->CreateNeg(outputCapacity))));
     1005        Value* outputPosRemOutputBlockSize = b->simd_and(outputPosVec, b->simd_fill(SIMD_WIDTH, b->CreateNot(b->CreateNeg(b->getIntN(SIMD_WIDTH, mOutputBlockSize)))));
     1006
     1007
     1008
     1009        Value* inputBasePtr = b->CreatePointerCast(b->getRawInputPointer("byteStream", b->getSize(0)), b->getInt8PtrTy());
     1010        Value* outputBasePtr = b->CreatePointerCast(b->getRawOutputPointer("outputStream", b->getSize(0)), b->getInt8PtrTy());
     1011
     1012        ////
     1013        // ---- i64LiteralCopy
     1014        BasicBlock* i64LiteralCopyCon = b->CreateBasicBlock("literalCopyCon");
     1015        BasicBlock* i64LiteralCopyBody = b->CreateBasicBlock("literalCopyBody");
     1016        BasicBlock* i64LiteralCopyExit = b->CreateBasicBlock("literalCopyExit");
     1017
     1018        b->CreateBr(i64LiteralCopyCon);
     1019
     1020        // ---- i64LiteralCopyCon
     1021        b->SetInsertPoint(i64LiteralCopyCon);
     1022
     1023
     1024        // ---- literalCopyBody
     1025        b->SetInsertPoint(i64LiteralCopyBody);
     1026
     1027        // ---- literalCopyExit
     1028        b->SetInsertPoint(i64LiteralCopyExit);
     1029
     1030
     1031        //// ---- i8LiteralCopyCon
     1032         */
    7611033    }
    7621034
  • icGREP/icgrep-devel/icgrep/kernels/lz4/lz4_parallel_bytestream_aio.h

    r6065 r6070  
    1 //
    2 // Created by wxy325 on 2018/5/31.
    3 //
    41
    52#ifndef ICGREP_LZ4_PARALLEL_BYTESTREAM_AIO_H
     
    107#include <map>
    118#include <vector>
     9#include <llvm/IR/DerivedTypes.h>
    1210
    1311namespace llvm {
     
    2624
    2725    public:
    28         LZ4ParallelByteStreamAioKernel(const std::unique_ptr<kernel::KernelBuilder> &b);
     26        // By default, output block size in LZ4 is 4MB
     27        LZ4ParallelByteStreamAioKernel(const std::unique_ptr<kernel::KernelBuilder> &b, size_t outputBlockSize = 4 * 1024 * 1024 );
    2928
    3029    protected:
     
    5756
    5857        void handleSimdLiteralCopy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* literalStartVec, llvm::Value* literalLengthVec, llvm::Value* outputPosVec);
     58        void generateSimdSequentialLiteralCopy(const std::unique_ptr<KernelBuilder> &b, llvm::Value *literalStartVec,
     59                                               llvm::Value *literalLengthVec, llvm::Value *outputPosVec);
     60
     61        void generateSimdSequentialLiteralCopyWithSimdCalculation(const std::unique_ptr<KernelBuilder> &b,
     62                                                                  llvm::Value *literalStartVec,
     63                                                                  llvm::Value *literalLengthVec,
     64                                                                  llvm::Value *outputPosVec);
     65        void generateSimdLiteralCopyByScatter(const std::unique_ptr<KernelBuilder> &b, llvm::Value *literalStartVec,
     66                                              llvm::Value *literalLengthVec, llvm::Value *outputPosVec);
     67        void generateSimdLiteralCopyByMemcpy(const std::unique_ptr<KernelBuilder> &b, llvm::Value *literalStartVec,
     68                                             llvm::Value *literalLengthVec, llvm::Value *outputPosVec);
     69
     70        void generateOverwritingMemcpy(const std::unique_ptr<KernelBuilder> &b, llvm::Value *inputBasePtr,
     71                                       llvm::Value *outputBasePtr, llvm::Value *copyBytes, llvm::PointerType *targetPtrTy,
     72                                       size_t stepSize);
     73        void generateOverwritingMemcpy(const std::unique_ptr<KernelBuilder> &b, llvm::Value *inputBasePtr,
     74                                       llvm::Value *outputBasePtr, llvm::Value *copyBytes, llvm::PointerType *targetPtrTy,
     75                                       llvm::Value* stepSize);
     76
    5977        void handleSimdMatchCopy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* matchOffsetVec, llvm::Value* matchLengthVec, llvm::Value* outputPosVec);
     78        void generateSimdMatchCopyByMemcpy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* matchOffsetVec, llvm::Value* matchLengthVec, llvm::Value* outputPosVec);
     79        void generateSimdSequentialMatchCopy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* matchOffsetVec, llvm::Value* matchLengthVec, llvm::Value* outputPosVec);
    6080
    6181        void handleLiteralCopy(const std::unique_ptr<KernelBuilder> &b, llvm::Value* literalStart, llvm::Value* literalLength, llvm::Value* outputPos);
     
    6989        llvm::Value* simdFetchByteDataByLoop(const std::unique_ptr<KernelBuilder> &b, llvm::Value* basePtr, llvm::Value* offsetVec, llvm::Value* mask);
    7090
    71 
     91        size_t mOutputBlockSize;
    7292    };
    7393
  • icGREP/icgrep-devel/icgrep/lz4/LZ4Generator.cpp

    r6066 r6070  
    472472
    473473    //// Generate Helper Markers Extenders
    474     StreamSetBuffer * const Extenders = mPxDriver.addBuffer<StaticBuffer>(iBuilder, iBuilder->getStreamSetTy(1, 1), this->getInputBufferBlocks(iBuilder), 1);
    475     mMatchOffsetMarker = mPxDriver.addBuffer<StaticBuffer>(iBuilder, iBuilder->getStreamSetTy(1, 1), this->getInputBufferBlocks(iBuilder));
    476     Kernel * extenderK = mPxDriver.addKernelInstance<ParabixCharacterClassKernelBuilder>(iBuilder, "extenders", std::vector<re::CC *>{re::makeCC(0xFF)}, 8);
    477     mPxDriver.makeKernelCall(extenderK, {mCompressedBasisBits}, {Extenders});
     474//    StreamSetBuffer * const Extenders = mPxDriver.addBuffer<StaticBuffer>(iBuilder, iBuilder->getStreamSetTy(1, 1), this->getInputBufferBlocks(iBuilder), 1);
     475//    mMatchOffsetMarker = mPxDriver.addBuffer<StaticBuffer>(iBuilder, iBuilder->getStreamSetTy(1, 1), this->getInputBufferBlocks(iBuilder));
     476//    Kernel * extenderK = mPxDriver.addKernelInstance<ParabixCharacterClassKernelBuilder>(iBuilder, "extenders", std::vector<re::CC *>{re::makeCC(0xFF)}, 8);
     477//    mPxDriver.makeKernelCall(extenderK, {mCompressedBasisBits}, {Extenders});
    478478
    479479    Kernel * blockDecoderK = mPxDriver.addKernelInstance<LZ4BlockDecoderNewKernel>(iBuilder);
     
    490490            {
    491491                    mCompressedByteStream,
    492                     Extenders,
    493492
    494493                    // Block Data
  • icGREP/icgrep-devel/icgrep/lz4/LZ4GrepGenerator.cpp

    r6066 r6070  
    610610    this->generateCountOnlyMainFunc(iBuilder);
    611611
    612     this->generateLoadByteStreamAndBitStream(iBuilder);
     612    this->generateLoadByteStream(iBuilder);
    613613    parabix::StreamSetBuffer * decompressedByteStream = this->generateParallelAIODecompression(iBuilder);
    614614
Note: See TracChangeset for help on using the changeset viewer.