Changeset 6133
- Timestamp:
- Jul 25, 2018, 2:50:09 AM (7 months ago)
- Location:
- icGREP/icgrep-devel/icgrep
- Files:
-
- 6 added
- 2 deleted
- 20 edited
Legend:
- Unmodified
- Added
- Removed
-
icGREP/icgrep-devel/icgrep/CMakeLists.txt
r6132 r6133 104 104 add_library(GrepEngine ${GREP_CORE_SRC} grep/grep_engine.cpp kernels/cc_kernel.cpp kernels/cc_scan_kernel.cpp kernels/charclasses.cpp kernels/streams_merge.cpp kernels/until_n.cpp kernels/UCD_property_kernel.cpp kernels/grapheme_kernel.cpp) 105 105 add_library(LZ4_Lib lz4FrameDecoder.cpp kernels/cc_kernel.cpp kernels/lz4/lz4_deposit_uncompressed.cpp kernels/lz4/lz4_generate_deposit_stream.cpp kernels/pdep_kernel.cpp lz4/LZ4Generator.cpp kernels/lz4/lz4_block_decoder.cpp kernels/lz4/lz4_index_builder.cpp kernels/lz4/lz4_swizzled_match_copy_kernel.cpp kernels/bitstream_pdep_kernel.cpp kernels/bitstream_gather_pdep_kernel.cpp kernels/swizzled_multiple_pdep_kernel.cpp kernels/lz4/lz4_bitstream_not_kernel.cpp kernels/lz4/lz4_bitstream_match_copy_kernel.cpp kernels/fake_stream_generating_kernel.cpp kernels/lz4/aio/lz4_bytestream_aio.cpp kernels/lz4/aio/lz4_swizzled_aio.cpp kernels/lz4/aio/lz4_parallel_bytestream_aio.cpp kernels/lz4/aio/lz4_sequential_aio_base.cpp kernels/lz4/aio/lz4_sequential_aio_base.h kernels/lz4/aio/lz4_bitstream_aio.cpp kernels/lz4/aio/lz4_bitstream_aio.h kernels/lz4/aio/lz4_i4_bytestream_aio.cpp kernels/lz4/aio/lz4_i4_bytestream_aio.h) 106 add_library(LZParabix_Lib lzparabix/LZParabixGenerator.cpp kernels/lzparabix/decoder/LZParabixBlockDecoder.cpp kernels/lzparabix/decoder/LZParabix BlockDecoder.h kernels/lzparabix/decoder/LZParabixAioKernel.cpp kernels/lzparabix/decoder/LZParabixAioKernel.h lzparabix/LZParabixGrepGenerator.cpp lzparabix/LZParabixGrepGenerator.h kernels/fake_stream_generating_kernel.cpp kernels/lzparabix/encoder/LZParabixCompressionKernel.cpp kernels/lzparabix/encoder/LZParabixCompressionKernel.h kernels/lzparabix/decoder/LZParabixLiteralDecoderKernel.cpp kernels/lzparabix/decoder/LZParabixLiteralDecoderKernel.h)106 add_library(LZParabix_Lib lzparabix/LZParabixGenerator.cpp kernels/lzparabix/decoder/LZParabixBlockDecoder.cpp kernels/lzparabix/decoder/LZParabixAioBaseKernel.cpp lzparabix/LZParabixGrepGenerator.cpp kernels/fake_stream_generating_kernel.cpp kernels/lzparabix/encoder/LZParabixCompressionKernel.cpp kernels/lzparabix/decoder/LZParabixLiteralDecoderKernel.cpp kernels/lzparabix/decoder/LZParabixBitStreamAioKernel.cpp kernels/lzparabix/decoder/LZParabixSwizzledAioKernel.cpp) 107 107 108 108 # force the compiler to compile the object cache to ensure that the versioning information is up to date -
icGREP/icgrep-devel/icgrep/cc/cc_compiler.cpp
r6127 r6133 27 27 } 28 28 29 Parabix_CC_Compiler::Parabix_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet, cc::BitNumbering basisSetNumbering , bool fakeBasisBits)29 Parabix_CC_Compiler::Parabix_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet, cc::BitNumbering basisSetNumbering) 30 30 : CC_Compiler(scope) 31 31 , mEncodingBits(basisBitSet.size()) 32 32 , mBasisSetNumbering(basisSetNumbering) 33 , mBasisBit(basisBitSet) 34 , mFakeBasisBits(fakeBasisBits) { 33 , mBasisBit(basisBitSet) { 35 34 mEncodingMask = (static_cast<unsigned>(1) << mEncodingBits) - static_cast<unsigned>(1); 36 35 } … … 228 227 template<typename PabloBlockOrBuilder> 229 228 inline PabloAST * Parabix_CC_Compiler::getBasisVar(const unsigned i, PabloBlockOrBuilder & pb) const { 230 if (mFakeBasisBits) { 231 return pb.createZeroes(); 232 } else { 233 assert (i < mEncodingBits); 234 if (mBasisSetNumbering == cc::BitNumbering::BigEndian) 235 return mBasisBit[mEncodingBits - i - 1]; 236 else return mBasisBit[i]; 237 } 229 assert (i < mEncodingBits); 230 if (mBasisSetNumbering == cc::BitNumbering::BigEndian) 231 return mBasisBit[mEncodingBits - i - 1]; 232 else return mBasisBit[i]; 238 233 } 239 234 -
icGREP/icgrep-devel/icgrep/cc/cc_compiler.h
r6127 r6133 41 41 public: 42 42 43 Parabix_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet, cc::BitNumbering b = BitNumbering::LittleEndian , bool fakeBasisBits = false);43 Parabix_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet, cc::BitNumbering b = BitNumbering::LittleEndian); 44 44 45 45 pablo::PabloAST * compileCC(const re::CC *cc) override; … … 77 77 std::vector<pablo::PabloAST *> mBasisBit; 78 78 unsigned mEncodingMask; 79 bool mFakeBasisBits;80 79 }; 81 80 -
icGREP/icgrep-devel/icgrep/cc/multiplex_CCs.cpp
r5934 r6133 138 138 CC_union = re::makeCC(CC_union, re::makeCC(i, this)); 139 139 } 140 CC_union->sourceCC = sourceCC; 140 141 return CC_union; 141 142 } -
icGREP/icgrep-devel/icgrep/kernels/fake_stream_generating_kernel.cpp
r6111 r6133 9 9 namespace kernel { 10 10 11 FakeStreamGeneratingKernel::FakeStreamGeneratingKernel(const std::unique_ptr<kernel::KernelBuilder> &b, 12 const unsigned numberOfInputStream, 13 const unsigned numberOfOutputStream, 14 std::string name) 15 : FakeStreamGeneratingKernel(b, numberOfInputStream, std::vector<unsigned>({numberOfOutputStream}), name) { 16 17 } 11 18 12 19 FakeStreamGeneratingKernel::FakeStreamGeneratingKernel(const std::unique_ptr<kernel::KernelBuilder> &b, 13 const unsigned intnumberOfInputStream,14 const unsigned int numberOfOutputStream,15 20 const unsigned numberOfInputStream, 21 std::vector<unsigned> numbersOfOutputStreams, 22 std::string name) 16 23 : MultiBlockKernel(std::move(name), 17 24 // input stream sets 18 25 {Binding{b->getStreamSetTy(numberOfInputStream), "inputStream", FixedRate(), Principal()}}, 19 26 // output stream set 20 { Binding{b->getStreamSetTy(numberOfOutputStream), "outputStream", RateEqualTo("inputStream")}},27 {}, 21 28 {}, {}, {}) { 22 29 for (unsigned i = 0; i < numbersOfOutputStreams.size(); i++) { 30 mStreamSetOutputs.push_back(Binding{b->getStreamSetTy(numbersOfOutputStreams[i]), "outputStream" + std::to_string(i), RateEqualTo("inputStream")}); 31 } 23 32 } 24 33 25 34 void FakeStreamGeneratingKernel::generateMultiBlockLogic(const std::unique_ptr<KernelBuilder> &b, 26 35 llvm::Value *const numOfStrides) { 27 36 } 37 28 38 } -
icGREP/icgrep-devel/icgrep/kernels/fake_stream_generating_kernel.h
r6111 r6133 6 6 #include <llvm/IR/Value.h> 7 7 #include <string> 8 #include <vector> 8 9 9 10 namespace IDISA { class IDISA_Builder; } … … 13 14 class FakeStreamGeneratingKernel final : public MultiBlockKernel { 14 15 public: 15 FakeStreamGeneratingKernel(const std::unique_ptr<kernel::KernelBuilder> & b, const unsigned numberOfInputStream = 1, const unsigned numberOfOutputStream = 1, std::string name = "LZ4FakeStreamGeneratingKernel"); 16 FakeStreamGeneratingKernel(const std::unique_ptr<kernel::KernelBuilder> & b, const unsigned numberOfInputStream = 1, const unsigned numberOfOutputStreams = 1, std::string name = "LZ4FakeStreamGeneratingKernel"); 17 FakeStreamGeneratingKernel(const std::unique_ptr<kernel::KernelBuilder> & b, const unsigned numberOfInputStream, std::vector<unsigned> numbersOfOutputStreams, std::string name = "LZ4FakeStreamGeneratingKernel"); 16 18 bool isCachable() const override { return true; } 17 19 bool hasSignature() const override { return false; } -
icGREP/icgrep-devel/icgrep/kernels/grep_kernel.cpp
r6127 r6133 250 250 } 251 251 252 ICGrepKernel::ICGrepKernel(const std::unique_ptr<kernel::KernelBuilder> & b, RE * const re, std::vector<std::string> externals, std::vector<cc::Alphabet *> alphabets, cc::BitNumbering basisSetNumbering , bool fakeBasisBits)252 ICGrepKernel::ICGrepKernel(const std::unique_ptr<kernel::KernelBuilder> & b, RE * const re, std::vector<std::string> externals, std::vector<cc::Alphabet *> alphabets, cc::BitNumbering basisSetNumbering) 253 253 : ICGrepSignature(re) 254 254 , PabloKernel(b, "ic" + sha1sum(mSignature), … … 259 259 , mExternals(externals) 260 260 , mAlphabets(alphabets) 261 , mBasisSetNumbering(basisSetNumbering) 262 , mFakeBasisBits(fakeBasisBits){ 261 , mBasisSetNumbering(basisSetNumbering) { 263 262 } 264 263 … … 269 268 void ICGrepKernel::generatePabloMethod() { 270 269 PabloBuilder pb(getEntryScope()); 271 cc::Parabix_CC_Compiler ccc(getEntryScope(), getInputStreamSet("basis"), mBasisSetNumbering , mFakeBasisBits);272 RE_Compiler re_compiler(getEntryScope(), ccc, mBasisSetNumbering , mFakeBasisBits);270 cc::Parabix_CC_Compiler ccc(getEntryScope(), getInputStreamSet("basis"), mBasisSetNumbering); 271 RE_Compiler re_compiler(getEntryScope(), ccc, mBasisSetNumbering); 273 272 for (auto & e : mExternals) { 274 273 re_compiler.addPrecompiled(e, pb.createExtract(getInputStreamVar(e), pb.getInteger(0))); -
icGREP/icgrep-devel/icgrep/kernels/grep_kernel.h
r6127 r6133 62 62 class ICGrepKernel : public ICGrepSignature, public pablo::PabloKernel { 63 63 public: 64 ICGrepKernel(const std::unique_ptr<kernel::KernelBuilder> & iBuilder, re::RE * const re_ast, std::vector<std::string> externals, std::vector<cc::Alphabet *> alphabets = {}, cc::BitNumbering basisSetNumbering = cc::BitNumbering::LittleEndian , bool fakeBasisBits = false);64 ICGrepKernel(const std::unique_ptr<kernel::KernelBuilder> & iBuilder, re::RE * const re_ast, std::vector<std::string> externals, std::vector<cc::Alphabet *> alphabets = {}, cc::BitNumbering basisSetNumbering = cc::BitNumbering::LittleEndian); 65 65 std::string makeSignature(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) override; 66 66 bool isCachable() const override { return true; } … … 70 70 std::vector<cc::Alphabet *> mAlphabets; 71 71 cc::BitNumbering mBasisSetNumbering; 72 bool mFakeBasisBits;73 72 }; 74 73 -
icGREP/icgrep-devel/icgrep/kernels/swizzle.cpp
r6026 r6133 7 7 #include <kernels/kernel_builder.h> 8 8 #include <string> 9 #include <vector> 9 10 10 11 using namespace llvm; … … 79 80 80 81 82 SwizzleByGather::SwizzleByGather(const std::unique_ptr<KernelBuilder> &iBuilder) 83 : BlockOrientedKernel("swizzleByGather", {}, {}, {}, {}, {}){ 84 for (unsigned i = 0; i < 2; i++) { 85 mStreamSetInputs.push_back(Binding{iBuilder->getStreamSetTy(4, 1), "inputGroup" + std::to_string(i)}); 86 } 87 for (unsigned i = 0; i < 1; i++) { 88 mStreamSetOutputs.push_back(Binding{iBuilder->getStreamSetTy(8, 1), "outputGroup" + std::to_string(i), FixedRate(1)}); 89 } 90 } 91 92 void SwizzleByGather::generateDoBlockMethod(const std::unique_ptr<kernel::KernelBuilder> &b) { 93 Value* outputStreamPtr = b->getOutputStreamBlockPtr("outputGroup0", b->getSize(0)); 94 95 for (unsigned i = 0; i < 2; i++) { 96 std::vector<llvm::Value*> inputStream; 97 Value* inputPtr = b->getInputStreamBlockPtr("inputGroup" + std::to_string(i), b->getSize(0)); 98 99 Value* inputBytePtr = b->CreatePointerCast(inputPtr, b->getInt8PtrTy()); 100 Function *gatherFunc = Intrinsic::getDeclaration(b->getModule(), Intrinsic::x86_avx2_gather_d_q_256); 101 Value *addresses = ConstantVector::get( 102 {b->getInt32(0), b->getInt32(32), b->getInt32(64), b->getInt32(96)}); 103 104 for (unsigned j = 0; j < 4; j++) { 105 Value *gather_result = b->CreateCall( 106 gatherFunc, 107 { 108 UndefValue::get(b->getBitBlockType()), 109 inputBytePtr, 110 addresses, 111 Constant::getAllOnesValue(b->getBitBlockType()), 112 b->getInt8(1) 113 } 114 ); 115 116 inputBytePtr = b->CreateGEP(inputBytePtr, b->getInt32(8)); 117 118 b->CreateStore(gather_result, outputStreamPtr); 119 outputStreamPtr = b->CreateGEP(outputStreamPtr, b->getSize(1)); 120 } 121 } 122 } 81 123 } -
icGREP/icgrep-devel/icgrep/kernels/swizzle.h
r6026 r6133 66 66 }; 67 67 68 69 class SwizzleByGather : public BlockOrientedKernel { 70 public: 71 SwizzleByGather(const std::unique_ptr<kernel::KernelBuilder> & iBuilder); 72 73 protected: 74 void generateDoBlockMethod(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) override; 75 private: 76 }; 77 68 78 } 69 79 -
icGREP/icgrep-devel/icgrep/lz4/LZ4GrepGenerator.cpp
r6132 r6133 405 405 406 406 StreamSetBuffer * LineBreakStream = mPxDriver.addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(1, 1), this->getInputBufferBlocks(idb)); 407 kernel::Kernel * lineFeedGrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, transformCCs(mpx.get(), linefeedCC), externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian , true);407 kernel::Kernel * lineFeedGrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, transformCCs(mpx.get(), linefeedCC), externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian); 408 408 mGrepDriver->makeKernelCall(lineFeedGrepK, {fakeMatchCopiedBits, decompressedCharClasses}, {LineBreakStream}); 409 409 410 410 411 kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[0], externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian , true);411 kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[0], externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian); 412 412 mGrepDriver->makeKernelCall(icgrepK, {fakeMatchCopiedBits, decompressedCharClasses}, {MatchResults}); 413 413 MatchResultsBufs[0] = MatchResults; … … 475 475 mGrepDriver->makeKernelCall(ccK, {decompressedBasisBits}, {CharClasses}); 476 476 477 kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[i], externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian , true);477 kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[i], externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian); 478 478 icgrepInputSets.push_back(CharClasses); 479 479 mGrepDriver->makeKernelCall(icgrepK, icgrepInputSets, {MatchResults}); -
icGREP/icgrep-devel/icgrep/lzparabix/LZParabixGenerator.cpp
r6123 r6133 1 //2 // Created by wxy325 on 2018/6/18.3 //4 1 5 2 #include "LZParabixGenerator.h" … … 22 19 #include <kernels/swizzled_multiple_pdep_kernel.h> 23 20 #include <kernels/lzparabix/decoder/LZParabixBlockDecoder.h> 24 #include <kernels/lzparabix/decoder/LZParabixAioKernel.h> 21 #include <kernels/lzparabix/decoder/LZParabixBitStreamAioKernel.h> 22 #include <kernels/lzparabix/decoder/LZParabixSwizzledAioKernel.h> 25 23 #include <kernels/lzparabix/decoder/LZParabixLiteralDecoderKernel.h> 26 24 … … 83 81 mPxDriver.makeKernelCall(literalDecoderK, {mCompressedByteStream, BlockData_BlockStart, BlockData_BlockEnd}, {LiteralBitStream}); 84 82 return LiteralBitStream; 83 } 84 85 86 87 parabix::StreamSetBuffer* LZParabixGenerator::generateSwizzledBitStreamDecompression(const std::unique_ptr<kernel::KernelBuilder> & iBuilder, parabix::StreamSetBuffer* inputBitStreams) { 88 89 Kernel * swizzleK = mPxDriver.addKernelInstance<SwizzleGenerator>(iBuilder, 8, 2, 1); 90 91 StreamSetBuffer* inputSwizzled1 = mPxDriver.addBuffer<StaticBuffer>(iBuilder, iBuilder->getStreamSetTy(4, 1), this->getInputBufferBlocks(iBuilder)); 92 StreamSetBuffer* inputSwizzled2 = mPxDriver.addBuffer<StaticBuffer>(iBuilder, iBuilder->getStreamSetTy(4, 1), this->getInputBufferBlocks(iBuilder)); 93 mPxDriver.makeKernelCall(swizzleK, {inputBitStreams}, {inputSwizzled1, inputSwizzled2}); 94 95 96 StreamSetBuffer* outputSwizzled1 = mPxDriver.addBuffer<StaticBuffer>(iBuilder, iBuilder->getStreamSetTy(4, 1), this->getInputBufferBlocks(iBuilder)); 97 StreamSetBuffer* outputSwizzled2 = mPxDriver.addBuffer<StaticBuffer>(iBuilder, iBuilder->getStreamSetTy(4, 1), this->getInputBufferBlocks(iBuilder)); 98 Kernel * aioK = mPxDriver.addKernelInstance<LZParabixSwizzledAioKernel>(iBuilder); 99 aioK->setInitialArguments({mFileSize}); 100 mPxDriver.makeKernelCall(aioK, { 101 mCompressedByteStream, 102 BlockData_BlockStart, 103 BlockData_BlockEnd, 104 105 // inputBitStreams, 106 inputSwizzled1, 107 inputSwizzled2 108 }, { 109 outputSwizzled1, 110 outputSwizzled2 111 }); 112 113 StreamSetBuffer * const decompressionBitStream = mPxDriver.addBuffer<StaticBuffer>(iBuilder, iBuilder->getStreamSetTy(8, 1), this->getDecompressedBufferBlocks(iBuilder)); 114 115 Kernel * unSwizzleK2 = mPxDriver.addKernelInstance<SwizzleGenerator>(iBuilder, 8, 1, 2); 116 // Kernel * unSwizzleK2 = mPxDriver.addKernelInstance<SwizzleByGather>(iBuilder); 117 mPxDriver.makeKernelCall(unSwizzleK2, {outputSwizzled1, outputSwizzled2}, {decompressionBitStream}); 118 return decompressionBitStream; 85 119 } 86 120 … … 101 135 } 102 136 103 Kernel * aioK = mPxDriver.addKernelInstance<LZParabix AioKernel>(iBuilder, numbersOfStreams);137 Kernel * aioK = mPxDriver.addKernelInstance<LZParabixBitStreamAioKernel>(iBuilder, numbersOfStreams); 104 138 aioK->setInitialArguments({mFileSize}); 105 139 mPxDriver.makeKernelCall(aioK, inputStreams, outputStreams); … … 133 167 } 134 168 135 Kernel * aioK = mPxDriver.addKernelInstance<LZParabix AioKernel>(iBuilder, numsOfStreams);169 Kernel * aioK = mPxDriver.addKernelInstance<LZParabixBitStreamAioKernel>(iBuilder, numsOfStreams); 136 170 aioK->setInitialArguments({mFileSize}); 137 171 -
icGREP/icgrep-devel/icgrep/lzparabix/LZParabixGenerator.h
r6123 r6133 67 67 parabix::StreamSetBuffer* extractLiteralBitStream(const std::unique_ptr<kernel::KernelBuilder> & iBuilder); 68 68 69 70 parabix::StreamSetBuffer* generateSwizzledBitStreamDecompression(const std::unique_ptr<kernel::KernelBuilder> & iBuilder, parabix::StreamSetBuffer* inputBitStreams); 69 71 std::vector<parabix::StreamSetBuffer*> generateBitStreamDecompression(const std::unique_ptr<kernel::KernelBuilder> & iBuilder, std::vector<parabix::StreamSetBuffer*> inputBitStreams); 70 72 }; -
icGREP/icgrep-devel/icgrep/lzparabix/LZParabixGrepGenerator.cpp
r6130 r6133 119 119 } 120 120 121 void LZParabixGrepGenerator::generateCountOnlyAioPipeline(re::RE *regex ) {121 void LZParabixGrepGenerator::generateCountOnlyAioPipeline(re::RE *regex, bool swizzledDecompression ) { 122 122 auto & iBuilder = mPxDriver.getBuilder(); 123 123 this->generateCountOnlyMainFunc(iBuilder); … … 132 132 std::tie(LineBreakStream, Matches) = multiplexingGrepPipeline(res); 133 133 } else { 134 std::tie(LineBreakStream, Matches) = grepPipeline(res );134 std::tie(LineBreakStream, Matches) = grepPipeline(res, swizzledDecompression); 135 135 } 136 136 … … 201 201 mGrepDriver->makeKernelCall(ccK, {LiteralBitStream}, {CharClasses}); 202 202 203 204 203 StreamSetBuffer * newLineBreak = nullptr; 204 205 206 StreamSetBuffer * decompressedCharClasses = nullptr; 207 StreamSetBuffer * u8NoFinalStream = nullptr; 208 StreamSetBuffer * fakeMatchCopiedBits = nullptr; 209 205 210 if (allCcByteLength) { 206 211 auto ret = this->generateBitStreamDecompression(idb, {CharClasses}); 207 StreamSetBuffer * decompressedCharClasses = ret[0]; 208 StreamSetBuffer * fakeMatchCopiedBits = mPxDriver.addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(8), this->getInputBufferBlocks(idb), 1); 209 Kernel* fakeStreamGeneratorK = mPxDriver.addKernelInstance<FakeStreamGeneratingKernel>(idb, numOfCharacterClasses, 8); 210 mPxDriver.makeKernelCall(fakeStreamGeneratorK, {decompressedCharClasses}, {fakeMatchCopiedBits}); 211 212 newLineBreak = mPxDriver.addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(1, 1), this->getInputBufferBlocks(idb)); 213 kernel::Kernel * lineFeedGrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, transformCCs(mpx.get(), linefeedCC), externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian, true); 214 mGrepDriver->makeKernelCall(lineFeedGrepK, {fakeMatchCopiedBits, decompressedCharClasses}, {newLineBreak}); 215 216 kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[0], externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian, true); 217 mGrepDriver->makeKernelCall(icgrepK, {fakeMatchCopiedBits, decompressedCharClasses}, {MatchResults}); 218 MatchResultsBufs[0] = MatchResults; 212 decompressedCharClasses = ret[0]; 213 fakeMatchCopiedBits = mPxDriver.addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(8), this->getInputBufferBlocks(idb), 1); 214 u8NoFinalStream = mPxDriver.addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(1), this->getInputBufferBlocks(idb), 1); 215 216 Kernel* fakeStreamGeneratorK = mPxDriver.addKernelInstance<FakeStreamGeneratingKernel>(idb, numOfCharacterClasses, std::vector<unsigned>({8, 1})); 217 mPxDriver.makeKernelCall(fakeStreamGeneratorK, {decompressedCharClasses}, {fakeMatchCopiedBits, u8NoFinalStream}); 219 218 } else { 220 219 re::RE* nonFinalName = re::makeAlt({re::makeByte(0xC2, 0xF4), … … 227 226 auto ret = this->generateBitStreamDecompression(idb, {CharClasses, compressedU8NoFinalStream}); 228 227 229 StreamSetBuffer *decompressedCharClasses = ret[0];230 StreamSetBuffer *u8NoFinalStream = ret[1];231 232 StreamSetBuffer *fakeMatchCopiedBits = mPxDriver.addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(8), this->getInputBufferBlocks(idb), 1);228 decompressedCharClasses = ret[0]; 229 u8NoFinalStream = ret[1]; 230 231 fakeMatchCopiedBits = mPxDriver.addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(8), this->getInputBufferBlocks(idb), 1); 233 232 Kernel* fakeStreamGeneratorK = mPxDriver.addKernelInstance<FakeStreamGeneratingKernel>(idb, numOfCharacterClasses, 8); 234 233 mPxDriver.makeKernelCall(fakeStreamGeneratorK, {decompressedCharClasses}, {fakeMatchCopiedBits}); 235 234 236 newLineBreak = mPxDriver.addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(1, 1), this->getInputBufferBlocks(idb)); 237 kernel::Kernel * lineFeedGrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, transformCCs(mpx.get(), linefeedCC), externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian, true); 238 mGrepDriver->makeKernelCall(lineFeedGrepK, {fakeMatchCopiedBits, decompressedCharClasses}, {newLineBreak}); 239 240 externalStreamNames.push_back("UTF8_nonfinal"); 241 242 kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[0], externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian); 243 mGrepDriver->makeKernelCall(icgrepK, {fakeMatchCopiedBits, u8NoFinalStream, decompressedCharClasses}, {MatchResults}); 244 MatchResultsBufs[0] = MatchResults; 245 } 235 } 236 237 238 newLineBreak = mPxDriver.addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(1, 1), this->getInputBufferBlocks(idb)); 239 kernel::Kernel * lineFeedGrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, transformCCs(mpx.get(), linefeedCC), externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian); 240 mGrepDriver->makeKernelCall(lineFeedGrepK, {fakeMatchCopiedBits, decompressedCharClasses}, {newLineBreak}); 241 242 externalStreamNames.push_back("UTF8_nonfinal"); 243 244 kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[0], externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()}, cc::BitNumbering::BigEndian); 245 mGrepDriver->makeKernelCall(icgrepK, {fakeMatchCopiedBits, u8NoFinalStream, decompressedCharClasses}, {MatchResults}); 246 MatchResultsBufs[0] = MatchResults; 247 246 248 247 249 StreamSetBuffer * MergedResults = MatchResultsBufs[0]; … … 272 274 273 275 std::pair<parabix::StreamSetBuffer *, parabix::StreamSetBuffer *> 274 LZParabixGrepGenerator::grepPipeline(std::vector<re::RE *> &REs ) {276 LZParabixGrepGenerator::grepPipeline(std::vector<re::RE *> &REs, bool swizzledDecompression) { 275 277 276 278 this->initREs(REs); … … 293 295 294 296 295 auto ret = this->generateBitStreamDecompression(idb, {LiteralBitStream/*, compressedLineBreakStream*/}); 296 StreamSetBuffer * decompressedBasisBits = ret[0]; 297 // StreamSetBuffer * LineBreakStream = ret[1]; 298 299 // StreamSetBuffer * decompressedBasisBits = this->generateAioBitStreamDecompressoin(idb, {mCompressedBasisBits})[0]; 297 StreamSetBuffer * decompressedBasisBits = nullptr; 298 if (swizzledDecompression) { 299 decompressedBasisBits = this->generateSwizzledBitStreamDecompression(idb, LiteralBitStream); 300 } else { 301 auto ret = this->generateBitStreamDecompression(idb, {LiteralBitStream}); 302 decompressedBasisBits = ret[0]; 303 } 304 300 305 StreamSetBuffer * LineBreakStream = this->linefeedStreamFromDecompressedBits(decompressedBasisBits); 301 306 -
icGREP/icgrep-devel/icgrep/lzparabix/LZParabixGrepGenerator.h
r6114 r6133 23 23 public: 24 24 LZParabixGrepGenerator(bool enableMultiplexing = false); 25 void generateCountOnlyAioPipeline(re::RE* regex );25 void generateCountOnlyAioPipeline(re::RE* regex, bool swizzledDecompression = false); 26 26 CountOnlyGrepMainFunctionType getCountOnlyGrepMainFunction(); 27 27 protected: … … 36 36 void initREs(std::vector<re::RE *> & REs); 37 37 38 std::pair<parabix::StreamSetBuffer *, parabix::StreamSetBuffer *> grepPipeline(std::vector<re::RE *> &REs );38 std::pair<parabix::StreamSetBuffer *, parabix::StreamSetBuffer *> grepPipeline(std::vector<re::RE *> &REs, bool swizzledDecompression); 39 39 std::pair<parabix::StreamSetBuffer *, parabix::StreamSetBuffer *> multiplexingGrepPipeline(std::vector<re::RE *> &REs); 40 40 -
icGREP/icgrep-devel/icgrep/lzparabix_grep.cpp
r6122 r6133 44 44 static cl::opt<bool> countOnly("count-only", cl::desc("Only count the match result"), cl::init(false), cl::cat(lz4GrepFlags)); 45 45 static cl::opt<bool> enableMultiplexing("enable-multiplexing", cl::desc("Enable CC multiplexing."), cl::init(false), cl::cat(lz4GrepFlags)); 46 static cl::opt<bool> swizzledDecompression("swizzled-decompression", cl::desc("Enable Swizzled Decompression."), cl::init(false), cl::cat(lz4GrepFlags)); 46 47 47 48 static cl::OptionCategory lz4GrepDebugFlags("LZ4 Grep Debug Flags", "lz4d debug options"); … … 79 80 LZParabixGrepGenerator g(enableMultiplexing); 80 81 81 g.generateCountOnlyAioPipeline(re_ast );82 g.generateCountOnlyAioPipeline(re_ast, swizzledDecompression); 82 83 auto main = g.getCountOnlyGrepMainFunction(); 83 84 uint64_t countResult = main(fileBuffer, 0, fileSize, false); -
icGREP/icgrep-devel/icgrep/re/re_analysis.cpp
r6130 r6133 163 163 if (srcA == &cc::Byte) { 164 164 return true; 165 } else if (cc->sourceCC) { 166 return isByteLength(cc->sourceCC); 165 167 // } else if (srcA == &cc::Unicode) { 166 168 // return cast<cc::MultiplexedAlphabet>(a)->invertCC(cc)->max_codepoint() <= 0x7F; -
icGREP/icgrep-devel/icgrep/re/re_cc.h
r5847 r6133 43 43 virtual ~CC() {} 44 44 45 const CC* sourceCC; 45 46 protected: 46 47 friend CC * makeCC(const cc::Alphabet * alphabet); -
icGREP/icgrep-devel/icgrep/re/re_compiler.cpp
r6127 r6133 49 49 void RE_Compiler::addAlphabet(cc::Alphabet * a, std::vector<pablo::PabloAST *> basis_set) { 50 50 mAlphabets.push_back(a); 51 mAlphabetCompilers.push_back(make_unique<cc::Parabix_CC_Compiler>(mEntryScope, basis_set, mBasisSetNumbering , false));51 mAlphabetCompilers.push_back(make_unique<cc::Parabix_CC_Compiler>(mEntryScope, basis_set, mBasisSetNumbering)); 52 52 } 53 53 … … 628 628 } 629 629 630 RE_Compiler::RE_Compiler(PabloBlock * scope, cc::CC_Compiler & ccCompiler, cc::BitNumbering basisSetNumbering , bool fakeBasisBits)630 RE_Compiler::RE_Compiler(PabloBlock * scope, cc::CC_Compiler & ccCompiler, cc::BitNumbering basisSetNumbering) 631 631 : mEntryScope(scope) 632 632 , mCCCompiler(ccCompiler) … … 635 635 , mStarDepth(0) 636 636 , mCompiledName(&mBaseMap) 637 , mBasisSetNumbering(basisSetNumbering) 638 , mFakeBasisBits(fakeBasisBits) { 637 , mBasisSetNumbering(basisSetNumbering) { 639 638 PabloBuilder pb(mEntryScope); 640 639 mLineBreak = pb.createZeroes(); // default so "^/$" matches start/end of text only -
icGREP/icgrep-devel/icgrep/re/re_compiler.h
r6127 r6133 52 52 }; 53 53 54 RE_Compiler(pablo::PabloBlock * scope, cc::CC_Compiler & ccCompiler, cc::BitNumbering basisSetNumbering = cc::BitNumbering::LittleEndian , bool mFakeBasisBits = false);54 RE_Compiler(pablo::PabloBlock * scope, cc::CC_Compiler & ccCompiler, cc::BitNumbering basisSetNumbering = cc::BitNumbering::LittleEndian); 55 55 56 56 // … … 149 149 std::map<std::string, pablo::PabloAST *> mExternalNameMap; 150 150 cc::BitNumbering mBasisSetNumbering; 151 bool mFakeBasisBits;152 151 }; 153 152
Note: See TracChangeset
for help on using the changeset viewer.