Ignore:
Timestamp:
Aug 11, 2018, 1:17:11 AM (13 months ago)
Author:
xwa163
Message:

lz4_grep: Init checkin for utf8 character class multiplexing

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

Legend:

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

    r6140 r6144  
    4242    }
    4343
    44 
    45 
    46 
    4744    TwistByPDEPKernel::TwistByPDEPKernel(const std::unique_ptr <kernel::KernelBuilder> &b, unsigned numberOfInputStream, unsigned twistWidth)
    4845            : BlockOrientedKernel("TwistByPDEPKernel",
     
    7572
    7673    TwistMultipleByPDEPKernel::TwistMultipleByPDEPKernel(const std::unique_ptr<kernel::KernelBuilder> &b,
    77                                                          unsigned numberOfInputStreamSet, unsigned twistWidth)
     74                     std::vector<unsigned> numberOfInputStreams, unsigned twistWidth)
    7875            : BlockOrientedKernel("TwistMultipleByPDEPKernel",
    7976                                  {},
    8077                                  {Binding{b->getStreamSetTy(1, twistWidth), "byteStream"}},
    8178                                  {}, {}, {}),
    82               mNumberOfInputStreamSet(numberOfInputStreamSet),
     79              mNumberOfInputStreams(numberOfInputStreams),
    8380              mTwistWidth(twistWidth)
    8481    {
    85         for (unsigned i = 0; i < numberOfInputStreamSet; i++) {
    86             mStreamSetInputs.push_back(Binding{b->getStreamSetTy(1), "basisBits_" + std::to_string(i) });
     82        assert(twistWidth == 2 || twistWidth == 4);
     83        size_t totalNumOfStreams = 0;
     84        for (unsigned i = 0; i < numberOfInputStreams.size(); i++) {
     85            totalNumOfStreams += numberOfInputStreams[i];
     86            mStreamSetInputs.push_back(Binding{b->getStreamSetTy(numberOfInputStreams[i]), "basisBits_" + std::to_string(i) });
    8787        }
     88        assert(totalNumOfStreams < twistWidth);
    8889    }
    8990
     
    9192        Value *inputBlocks[mTwistWidth];
    9293
    93         for (unsigned i = 0; i < mTwistWidth; i++) {
    94             if (i < mNumberOfInputStreamSet) {
    95                 inputBlocks[i] = b->loadInputStreamBlock("basisBits_" + std::to_string(i), b->getInt32(0));
    96                 if (i == 0) {
    97                     b->CallPrintRegister("basisBits_" + std::to_string(i), inputBlocks[i]);
    98                 }
    99             } else {
    100                 inputBlocks[i] = ConstantVector::getNullValue(b->getBitBlockType());
     94        unsigned iStreamIndex = 0;
     95        for (unsigned i = 0; i < mNumberOfInputStreams.size(); i++) {
     96            for (unsigned j = 0; j < mNumberOfInputStreams[i]; j++) {
     97                inputBlocks[iStreamIndex] = b->loadInputStreamBlock("basisBits_" + std::to_string(i), b->getInt32(j));
     98                ++iStreamIndex;
    10199            }
    102100        }
     101
     102        for (; iStreamIndex < mTwistWidth; iStreamIndex++) {
     103            inputBlocks[iStreamIndex] = ConstantVector::getNullValue(b->getBitBlockType());
     104        }
     105
    103106
    104107        Value *outputBasePtr = b->CreatePointerCast(b->getOutputStreamBlockPtr("byteStream", b->getSize(0)),
  • icGREP/icgrep-devel/icgrep/kernels/lz4/twist_kernel.h

    r6140 r6144  
    2525    class TwistMultipleByPDEPKernel final : public BlockOrientedKernel {
    2626    public:
    27         TwistMultipleByPDEPKernel(const std::unique_ptr <kernel::KernelBuilder> &b, unsigned numberOfInputStreamSet, unsigned twistWidth);
     27        TwistMultipleByPDEPKernel(const std::unique_ptr <kernel::KernelBuilder> &b, std::vector<unsigned> numberOfInputStreams, unsigned twistWidth);
    2828
    2929    private:
    30         const unsigned mNumberOfInputStreamSet;
     30        std::vector<unsigned> mNumberOfInputStreams;
    3131        const unsigned mTwistWidth;
    3232
  • icGREP/icgrep-devel/icgrep/kernels/lz4/untwist_kernel.cpp

    r6143 r6144  
    66
    77namespace kernel {
    8     UntwistByPEXTKernel::UntwistByPEXTKernel(const std::unique_ptr<kernel::KernelBuilder> &b, unsigned numberOfOutputStream, unsigned twistWidth)
    9             :BlockOrientedKernel("UntwistByPEXTKernel",
    10                                  {
    11                                          Binding{b->getStreamSetTy(1, twistWidth), "byteStream", FixedRate(), Principal()}
    12                                  },
    13                                  {
    14                                          Binding{b->getStreamSetTy(numberOfOutputStream, 1), "basisBits"}
    15                                  }, {}, {}, {}),
    16              mNumberOfOutputStream(numberOfOutputStream),
    17              mTwistWidth(twistWidth)
    18     {
    19         assert(twistWidth == 2 || twistWidth == 4);
    20         assert(numberOfInputStream <= twistWidth);
    218
    22     }
    23 
    24     void UntwistByPEXTKernel::generateDoBlockMethod(const std::unique_ptr<KernelBuilder> &b) {
     9    void untwistByPEXT(const std::unique_ptr <kernel::KernelBuilder> &b, Value* inputBasePtr, unsigned mTwistWidth, Value *outputBlocks[]){
    2510        Function* PEXT_func = Intrinsic::getDeclaration(b->getModule(), Intrinsic::x86_bmi_pext_64);
    26 
    2711        uint64_t pextBaseMask = mTwistWidth == 2 ? 0x5555555555555555: 0x1111111111111111;
    2812
    29         Value* inputBasePtr = b->CreatePointerCast(b->getInputStreamBlockPtr("byteStream", b->getSize(0)), b->getInt64Ty()->getPointerTo());
    30 
    31         Value* outputBlocks[mTwistWidth];
    3213        for (unsigned i = 0; i < mTwistWidth; i++) {
    3314            outputBlocks[i] = ConstantVector::getNullValue(b->getBitBlockType());
     
    6243            }
    6344        }
     45    }
     46
     47
     48
     49
     50    UntwistByPEXTKernel::UntwistByPEXTKernel(const std::unique_ptr<kernel::KernelBuilder> &b, unsigned numberOfOutputStream, unsigned twistWidth)
     51            :BlockOrientedKernel("UntwistByPEXTKernel",
     52                                 {
     53                                         Binding{b->getStreamSetTy(1, twistWidth), "byteStream", FixedRate(), Principal()}
     54                                 },
     55                                 {
     56                                         Binding{b->getStreamSetTy(numberOfOutputStream, 1), "basisBits"}
     57                                 }, {}, {}, {}),
     58             mNumberOfOutputStream(numberOfOutputStream),
     59             mTwistWidth(twistWidth)
     60    {
     61        assert(twistWidth == 2 || twistWidth == 4);
     62        assert(numberOfInputStream <= twistWidth);
     63
     64    }
     65
     66    void UntwistByPEXTKernel::generateDoBlockMethod(const std::unique_ptr<KernelBuilder> &b) {
     67        Value* inputBasePtr = b->CreatePointerCast(b->getInputStreamBlockPtr("byteStream", b->getSize(0)), b->getInt64Ty()->getPointerTo());
     68        Value* outputBlocks[mTwistWidth];
     69
     70        untwistByPEXT(b, inputBasePtr, mTwistWidth, outputBlocks);
    6471
    6572        for (unsigned i = 0; i < mNumberOfOutputStream; i++) {
    6673            b->storeOutputStreamBlock("basisBits", b->getInt32(i), outputBlocks[i]);
     74        }
     75    }
     76
     77
     78    UntwistMultipleByPEXTKernel::UntwistMultipleByPEXTKernel(const std::unique_ptr<kernel::KernelBuilder> &b,
     79                                                             std::vector<unsigned> numberOfOutputStreams,
     80                                                             unsigned twistWidth) :
     81            BlockOrientedKernel("UntwistMultipleByPEXTKernel",
     82                                {
     83                                        Binding{b->getStreamSetTy(1, twistWidth), "byteStream", FixedRate(),
     84                                                Principal()}
     85                                },
     86                                {
     87                                        //Binding{b->getStreamSetTy(numberOfOutputStream, 1), "basisBits"}
     88                                }, {}, {}, {}),
     89            mNumberOfOutputStreams(numberOfOutputStreams),
     90            mTwistWidth(twistWidth) {
     91        assert(twistWidth == 2 || twistWidth == 4);
     92
     93        size_t totalNumOfStreams = 0;
     94        for (unsigned i = 0; i < numberOfOutputStreams.size(); i++) {
     95            totalNumOfStreams += numberOfOutputStreams[i];
     96            mStreamSetOutputs.push_back(Binding{b->getStreamSetTy(numberOfOutputStreams[i]), "basisBits_" + std::to_string(i) });
     97        }
     98        assert(totalNumOfStreams < twistWidth);
     99    }
     100
     101    void UntwistMultipleByPEXTKernel::generateDoBlockMethod(const std::unique_ptr<KernelBuilder> &b) {
     102        Value* inputBasePtr = b->CreatePointerCast(b->getInputStreamBlockPtr("byteStream", b->getSize(0)), b->getInt64Ty()->getPointerTo());
     103        Value* outputBlocks[mTwistWidth];
     104        untwistByPEXT(b, inputBasePtr, mTwistWidth, outputBlocks);
     105
     106        unsigned iStreamIndex = 0;
     107        for (unsigned i = 0; i < mNumberOfOutputStreams.size(); i++) {
     108            for (unsigned j = 0; j < mNumberOfOutputStreams[i]; j++) {
     109                b->storeOutputStreamBlock("basisBits_" + std::to_string(i), b->getInt32(j), outputBlocks[iStreamIndex]);
     110                iStreamIndex++;
     111            }
    67112        }
    68113    }
  • icGREP/icgrep-devel/icgrep/kernels/lz4/untwist_kernel.h

    r6143 r6144  
    1313    class UntwistByPEXTKernel final : public BlockOrientedKernel{
    1414    public:
    15         UntwistByPEXTKernel(const std::unique_ptr<kernel::KernelBuilder> & b, unsigned numberOfOutputStream = 4, unsigned twistWidth = 2);
     15        UntwistByPEXTKernel(const std::unique_ptr<kernel::KernelBuilder> & b, unsigned numberOfOutputStream, unsigned twistWidth);
    1616    protected:
    1717        const size_t mNumberOfOutputStream;
     
    1919        void generateDoBlockMethod(const std::unique_ptr<KernelBuilder> & b) override;
    2020    };
     21
     22    class UntwistMultipleByPEXTKernel final : public BlockOrientedKernel{
     23    public:
     24        UntwistMultipleByPEXTKernel(const std::unique_ptr<kernel::KernelBuilder> & b, std::vector<unsigned> numberOfOutputStreams, unsigned twistWidth);
     25    protected:
     26        const std::vector<unsigned> mNumberOfOutputStreams;
     27        const size_t mTwistWidth;
     28        void generateDoBlockMethod(const std::unique_ptr<KernelBuilder> & b) override;
     29    };
     30
    2131
    2232    class StreamCompareKernel final : public BlockOrientedKernel{
Note: See TracChangeset for help on using the changeset viewer.