Ignore:
Timestamp:
Jul 23, 2018, 4:56:33 AM (12 months ago)
Author:
xwa163
Message:
  1. More experiment on lz4 grep
  2. Improve performance of lzparabix grep
File:
1 edited

Legend:

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

    r6112 r6132  
    2424        Value * x0 = iBuilder->esimd_mergel(128, s0, s1);
    2525        Value * x1 = iBuilder->esimd_mergeh(128, s0, s1);
    26         t0 = iBuilder->hsimd_packh_in_lanes(PACK_LANES, 16, x0, x1);
     26
     27        t0 = iBuilder->hsimd_packh_in_lanes(PACK_LANES, 16, x0, x1); // TODO 4䞪bit streams时这里的16改䞺8?
    2728        t1 = iBuilder->hsimd_packl_in_lanes(PACK_LANES, 16, x0, x1);
     29
    2830    } else {
    2931        t0 = iBuilder->hsimd_packh(16, s0, s1);
    3032        t1 = iBuilder->hsimd_packl(16, s0, s1);
    3133    }
     34    if (shift == 1) {
     35//        iBuilder->CallPrintRegister("t0", t0);
     36//        iBuilder->CallPrintRegister("t1", t1);
     37    }
     38
    3239    p0 = iBuilder->simd_if(1, hi_mask, t0, iBuilder->simd_srli(16, t1, shift));
    3340    p1 = iBuilder->simd_if(1, hi_mask, iBuilder->simd_slli(16, t0, shift), t1);
     
    3542
    3643void s2p(const std::unique_ptr<KernelBuilder> & iBuilder, Value * input[], Value * output[], cc::BitNumbering basisNumbering) {
     44    {
     45        //input[0 - 3]
     46        Value* bit3311[2];
     47        Value* bit2200[2];
     48        for (unsigned i = 0; i < 2; i++) {
     49            s2p_step(iBuilder, input[2 * i], input[2 * i + 1], iBuilder->simd_himask(2), 1, bit3311[i], bit2200[i]);
     50        }
     51
     52        Value* out[4];
     53        s2p_step(iBuilder, bit3311[0], bit3311[1],
     54                 iBuilder->simd_himask(4), 2, out[3], out[1]);
     55
     56        s2p_step(iBuilder, bit2200[0], bit2200[1],
     57                 iBuilder->simd_himask(4), 2, out[2], out[0]);
     58        for (unsigned i = 0; i < 4; i++) {
     59//            iBuilder->CallPrintRegister("input" + std::to_string(i), input[i]);
     60        }
     61        for (unsigned i = 0; i < 4; i++) {
     62//            iBuilder->CallPrintRegister("out" + std::to_string(i), out[i]);
     63        }
     64    }
     65
     66
    3767    // Little-endian bit number is used for variables.
    3868    Value * bit66442200[4];
    3969    Value * bit77553311[4];
     70//    iBuilder->CallPrintRegister("himask2", iBuilder->simd_himask(2));
     71//    iBuilder->CallPrintRegister("himask4", iBuilder->simd_himask(4));
     72//    iBuilder->CallPrintRegister("himask8", iBuilder->simd_himask(8));
    4073
    4174    for (unsigned i = 0; i < 4; i++) {
    4275        Value * s0 = input[2 * i];
    4376        Value * s1 = input[2 * i + 1];
     77//        iBuilder->CallPrintRegister("s0_" + std::to_string(2 * i), s0);
     78//        iBuilder->CallPrintRegister("s1_" + std::to_string(2 * i + 1), s1);
    4479        s2p_step(iBuilder, s0, s1, iBuilder->simd_himask(2), 1, bit77553311[i], bit66442200[i]);
     80//        iBuilder->CallPrintRegister("bit77553311", bit77553311[i]);
     81//        iBuilder->CallPrintRegister("bit66442200", bit66442200[i]);
    4582    }
    4683    Value * bit44440000[2];
     
    65102        s2p_step(iBuilder, bit66662222[0], bit66662222[1], iBuilder->simd_himask(8), 4, output[1], output[5]);
    66103        s2p_step(iBuilder, bit77773333[0], bit77773333[1], iBuilder->simd_himask(8), 4, output[0], output[4]);
     104    }
     105
     106    for (unsigned i = 0; i < 8; i++) {
     107//        iBuilder->CallPrintRegister("input" + std::to_string(i), input[i]);
     108    }
     109    for (unsigned i = 0; i < 8; i++) {
     110//        iBuilder->CallPrintRegister("output" + std::to_string(i), output[i]);
    67111    }
    68112}
     
    110154}
    111155#endif
    112    
     156
     157
     158    S2P4StreamByPEXTKernel::S2P4StreamByPEXTKernel(const std::unique_ptr<kernel::KernelBuilder> & b)
     159            :BlockOrientedKernel("s2p4StreamByPEXT",
     160                                 {
     161                                         Binding{b->getStreamSetTy(1, 4), "byteStream", FixedRate(), Principal()}
     162                                 },
     163                                 {
     164                                         Binding{b->getStreamSetTy(4, 1), "basisBits"}
     165                                 }, {}, {}, {}) {
     166
     167    }
     168
     169    void S2P4StreamByPEXTKernel::generateDoBlockMethod(const std::unique_ptr<KernelBuilder> & b) {
     170        Function* PEXT_func = Intrinsic::getDeclaration(b->getModule(), Intrinsic::x86_bmi_pext_64);
     171        uint64_t pextBaseMask = 0x1111111111111111;
     172
     173        Value* inputBasePtr = b->CreatePointerCast(b->getInputStreamBlockPtr("byteStream", b->getSize(0)), b->getInt64Ty()->getPointerTo());
     174
     175        Value* outputBlocks[4];
     176        for (unsigned i = 0; i < 4; i++) {
     177            outputBlocks[i] = ConstantVector::getNullValue(b->getBitBlockType());
     178        }
     179
     180        for (unsigned i = 0; i < b->getBitBlockWidth() / 64; i++) {
     181            Value* currentOutput[4];
     182            for (unsigned iIndex = 0; iIndex < 4; iIndex++) {
     183                currentOutput[iIndex] = b->getInt64(0);
     184            }
     185
     186            for (unsigned j = 0; j < 4; j++) {
     187                unsigned inputIndex = i * 4 + j;
     188
     189                Value* currentInput = b->CreateLoad(b->CreateGEP(inputBasePtr, b->getInt32(inputIndex)));
     190                for (unsigned k = 0; k < 4; k++) {
     191
     192                    Value* newBits = b->CreateCall(
     193                            PEXT_func,{
     194                                    currentInput,
     195                                    b->getInt64(pextBaseMask << k)
     196                            }
     197                    );
     198
     199                    currentOutput[k] = b->CreateOr(currentOutput[k], b->CreateShl(newBits, 16 * j));
     200                }
     201            }
     202
     203            for (unsigned iIndex = 0; iIndex < 4; iIndex++) {
     204                outputBlocks[iIndex] = b->CreateInsertElement(outputBlocks[iIndex], currentOutput[iIndex], i);
     205            }
     206        }
     207
     208        for (unsigned i = 0; i < 4; i++) {
     209            b->storeOutputStreamBlock("basisBits", b->getInt32(i), outputBlocks[i]);
     210//            b->CallPrintRegister("outputBlocks" + std::to_string(i), outputBlocks[i]);
     211        }
     212    }
     213
    113214void S2PKernel::generateMultiBlockLogic(const std::unique_ptr<KernelBuilder> & kb, Value * const numOfBlocks) {
    114215    BasicBlock * entry = kb->GetInsertBlock();
     
    135236    Value * basisbits[8];
    136237    s2p(kb, bytepack, basisbits, mBasisSetNumbering);
    137     for (unsigned i = 0; i < 8; ++i) {
     238    for (unsigned i = 0; i < mNumOfStreams; ++i) {
    138239        kb->storeOutputStreamBlock("basisBits", kb->getInt32(i), blockOffsetPhi, basisbits[i]);
    139240    }
     
    145246}
    146247
    147 S2PKernel::S2PKernel(const std::unique_ptr<KernelBuilder> & b, cc::BitNumbering numbering, bool aligned, std::string prefix)
     248S2PKernel::S2PKernel(const std::unique_ptr<KernelBuilder> & b, cc::BitNumbering numbering, bool aligned, std::string prefix, unsigned numOfStreams)
    148249    : MultiBlockKernel(aligned ? prefix + "s2p" + cc::numberingSuffix(numbering): prefix + "s2p_unaligned" + cc::numberingSuffix(numbering),
    149250    {Binding{b->getStreamSetTy(1, 8), "byteStream", FixedRate(), Principal()}},
    150     {Binding{b->getStreamSetTy(8, 1), "basisBits"}}, {}, {}, {}),
     251    {Binding{b->getStreamSetTy(numOfStreams, 1), "basisBits"}}, {}, {}, {}),
    151252  mBasisSetNumbering(numbering),
    152   mAligned(aligned) {
     253  mAligned(aligned),
     254  mNumOfStreams(numOfStreams)
     255{
    153256    if (!aligned) {
    154257        mStreamSetInputs[0].addAttribute(Misaligned());
Note: See TracChangeset for help on using the changeset viewer.