source: icGREP/icgrep-devel/icgrep/lz4/grep/lz4_grep_bytestream_generator.cpp @ 6144

Last change on this file since 6144 was 6144, checked in by xwa163, 6 weeks ago

lz4_grep: Init checkin for utf8 character class multiplexing

File size: 9.9 KB
Line 
1
2#include "lz4_grep_bytestream_generator.h"
3#include <kernels/lz4/twist_kernel.h>
4#include <kernels/lz4/decompression/lz4_twist_decompression.h>
5#include <kernels/lz4/untwist_kernel.h>
6#include <kernels/s2p_kernel.h>
7#include <kernels/p2s_kernel.h>
8#include <kernels/lz4/decompression/lz4_bytestream_decompression.h>
9#include <kernels/kernel_builder.h>
10
11
12using namespace kernel;
13using namespace parabix;
14
15StreamSetBuffer *LZ4GrepByteStreamGenerator::generateUncompressedBitStreams() {
16    StreamSetBuffer* compressedByteStream = this->loadByteStream();
17    parabix::StreamSetBuffer * uncompressedByteStream = this->byteStreamDecompression(compressedByteStream);
18    return this->s2p(uncompressedByteStream);
19}
20
21parabix::StreamSetBuffer *
22LZ4GrepByteStreamGenerator::decompressBitStream(parabix::StreamSetBuffer *compressedByteStream,
23                                                parabix::StreamSetBuffer *compressedBitStream) {
24    return this->convertCompressedBitsStreamWithTwistApproach(compressedByteStream, compressedBitStream, "combined");
25}
26
27
28parabix::StreamSetBuffer * LZ4GrepByteStreamGenerator::convertCompressedBitsStreamWithTwistApproach(
29        parabix::StreamSetBuffer *compressedByteStream,
30        parabix::StreamSetBuffer *compressedBitStream,
31        std::string prefix
32) {
33    auto & b = mPxDriver.getBuilder();
34
35    LZ4BlockInfo blockInfo = this->getBlockInfo(compressedByteStream);
36
37    unsigned numOfStreams = compressedBitStream->getNumOfStreams();
38
39    if (numOfStreams == 1) {
40
41        StreamSetBuffer* uncompressedBitStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 1),
42                                                                                   this->getDefaultBufferBlocks(), 1);
43        Kernel* lz4I4AioK = mPxDriver.addKernelInstance<LZ4TwistDecompressionKernel>(b, 1);
44        lz4I4AioK->setInitialArguments({mFileSize});
45        mPxDriver.makeKernelCall(lz4I4AioK, {
46                compressedByteStream,
47
48                blockInfo.isCompress,
49                blockInfo.blockStart,
50                blockInfo.blockEnd,
51
52                compressedBitStream
53//                , uncompressedBitStream2
54        }, {
55                                         uncompressedBitStream
56                                 });
57
58
59//        Kernel* streamCmp = mPxDriver.addKernelInstance<StreamCompareKernel>(b, 1);
60//        mPxDriver.makeKernelCall(streamCmp, {
61//                uncompressedBitStream,
62//                uncompressedBitStream2
63//        }, {});
64
65        return uncompressedBitStream;
66    }
67    if (numOfStreams <= 2) {
68        StreamSetBuffer* twistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 2),
69                                                                                this->getDefaultBufferBlocks(), 1);
70        kernel::Kernel* twistK = mPxDriver.addKernelInstance<kernel::TwistMultipleByPDEPKernel>(b, std::vector<unsigned>{numOfStreams}, 2);
71        mPxDriver.makeKernelCall(twistK, {compressedBitStream}, {twistedCharClasses});
72
73
74        StreamSetBuffer* uncompressedTwistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 2),
75                                                                                            this->getDefaultBufferBlocks(), 1);
76        Kernel* lz4I4AioK = mPxDriver.addKernelInstance<LZ4TwistDecompressionKernel>(b, 2);
77        lz4I4AioK->setInitialArguments({mFileSize});
78        mPxDriver.makeKernelCall(lz4I4AioK, {
79                compressedByteStream,
80
81                blockInfo.isCompress,
82                blockInfo.blockStart,
83                blockInfo.blockEnd,
84
85                twistedCharClasses
86        }, {
87                                         uncompressedTwistedCharClasses
88                                 });
89
90        StreamSetBuffer* untwistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(numOfStreams),
91                                                                                  this->getDefaultBufferBlocks(), 1);
92        kernel::Kernel* untwistK = mPxDriver.addKernelInstance<kernel::UntwistMultipleByPEXTKernel>(b, std::vector<unsigned>{numOfStreams}, 2);
93        mPxDriver.makeKernelCall(untwistK, {uncompressedTwistedCharClasses}, {untwistedCharClasses});
94        return untwistedCharClasses;
95    }
96    if (numOfStreams <= 4) {
97        StreamSetBuffer* twistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 4),
98                                                                                this->getDefaultBufferBlocks(), 1);
99        kernel::Kernel* twistK = mPxDriver.addKernelInstance<kernel::TwistMultipleByPDEPKernel>(b, std::vector<unsigned>{numOfStreams}, 4);
100        mPxDriver.makeKernelCall(twistK, {compressedBitStream}, {twistedCharClasses});
101
102
103        StreamSetBuffer* uncompressedTwistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 4),
104                                                                                            this->getDefaultBufferBlocks(), 1);
105
106        Kernel* lz4I4AioK = mPxDriver.addKernelInstance<LZ4TwistDecompressionKernel>(b, 4);
107        lz4I4AioK->setInitialArguments({mFileSize});
108        mPxDriver.makeKernelCall(lz4I4AioK, {
109                compressedByteStream,
110
111                blockInfo.isCompress,
112                blockInfo.blockStart,
113                blockInfo.blockEnd,
114
115                twistedCharClasses
116        }, {
117                                         uncompressedTwistedCharClasses
118                                 });
119
120        StreamSetBuffer* untwistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(numOfStreams),
121                                                                                  this->getDefaultBufferBlocks(), 1);
122        kernel::Kernel* untwistK = mPxDriver.addKernelInstance<kernel::UntwistMultipleByPEXTKernel>(b, std::vector<unsigned>{numOfStreams}, 4);
123        mPxDriver.makeKernelCall(untwistK, {uncompressedTwistedCharClasses}, {untwistedCharClasses});
124        return untwistedCharClasses;
125    }
126
127    // <= 8
128    StreamSetBuffer * const mtxByteStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 8),
129                                                                              this->getDefaultBufferBlocks());
130    Kernel * p2sK = mPxDriver.addKernelInstance<P2SKernel>(b, cc::BitNumbering::BigEndian, prefix, numOfStreams);
131    mPxDriver.makeKernelCall(p2sK, {compressedBitStream}, {mtxByteStream});
132
133
134    StreamSetBuffer * const decompressionMtxByteStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 8),
135                                                                                           this->getDefaultBufferBlocks(), 1);
136    Kernel* lz4AioK = mPxDriver.addKernelInstance<LZ4ByteStreamDecompressionKernel>(b, true);
137    lz4AioK->setInitialArguments({mFileSize});
138    mPxDriver.makeKernelCall(
139            lz4AioK,
140            {
141                    compressedByteStream,
142                    // Block Data
143                    blockInfo.isCompress,
144                    blockInfo.blockStart,
145                    blockInfo.blockEnd,
146                    mtxByteStream
147            }, {
148                    decompressionMtxByteStream
149            });
150
151    StreamSetBuffer * const uncompressedMtxBitStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(numOfStreams),
152                                                                                         this->getDefaultBufferBlocks());
153
154    Kernel * s2pk = mPxDriver.addKernelInstance<S2PKernel>(b, cc::BitNumbering::BigEndian, true, prefix, numOfStreams);
155    mPxDriver.makeKernelCall(s2pk, {decompressionMtxByteStream}, {uncompressedMtxBitStream});
156    return uncompressedMtxBitStream;
157}
158
159std::vector<parabix::StreamSetBuffer *>
160LZ4GrepByteStreamGenerator::decompressBitStreams(parabix::StreamSetBuffer *compressedByteStream,
161                                                 std::vector<parabix::StreamSetBuffer *> compressedBitStreams) {
162
163
164    auto & b = mPxDriver.getBuilder();
165    LZ4BlockInfo blockInfo = this->getBlockInfo(compressedByteStream);
166
167    unsigned totalStreamNum = 0;
168    std::vector<unsigned> numOfStreams;
169    std::vector<StreamSetBuffer*> retStreams;
170    for (unsigned i = 0; i < compressedBitStreams.size(); i++) {
171        unsigned n = compressedBitStreams[i]->getNumOfStreams();
172
173        numOfStreams.push_back(n);
174        totalStreamNum += n;
175        retStreams.push_back(mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(n), this->getDefaultBufferBlocks(), 1));
176    }
177
178    if (totalStreamNum == 1) {
179        // TODO
180    } else if (totalStreamNum <= 4) {
181        unsigned twistWidth = totalStreamNum == 2 ? 2 : 4;
182
183        StreamSetBuffer* twistedStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, twistWidth),
184                                                                                this->getDefaultBufferBlocks(), 1);
185        kernel::Kernel* twistK = mPxDriver.addKernelInstance<kernel::TwistMultipleByPDEPKernel>(b, numOfStreams, twistWidth);
186        mPxDriver.makeKernelCall(twistK, compressedBitStreams, {twistedStream});
187
188        StreamSetBuffer* uncompressedTwistedStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, twistWidth),
189                                                                                            this->getDefaultBufferBlocks(), 1);
190        Kernel* lz4I4AioK = mPxDriver.addKernelInstance<LZ4TwistDecompressionKernel>(b, twistWidth);
191        lz4I4AioK->setInitialArguments({mFileSize});
192        mPxDriver.makeKernelCall(lz4I4AioK, {
193                compressedByteStream,
194
195                blockInfo.isCompress,
196                blockInfo.blockStart,
197                blockInfo.blockEnd,
198
199                twistedStream
200        }, {
201                uncompressedTwistedStream
202                                 });
203
204        kernel::Kernel* untwistK = mPxDriver.addKernelInstance<kernel::UntwistMultipleByPEXTKernel>(b, numOfStreams, twistWidth);
205        mPxDriver.makeKernelCall(untwistK, {uncompressedTwistedStream}, retStreams);
206    } else {
207        // TODO
208    }
209    return retStreams;
210}
Note: See TracBrowser for help on using the repository browser.