source: icGREP/icgrep-devel/icgrep/kernels/lzparabix/decoder/LZParabixLiteralDecoderKernel.cpp @ 6123

Last change on this file since 6123 was 6123, checked in by xwa163, 13 months ago

Encode BitStream? directly in LZParabix compressed file

File size: 5.4 KB
Line 
1//
2// Created by wxy325 on 2018/6/30.
3//
4
5#include "LZParabixLiteralDecoderKernel.h"
6#include <kernels/kernel_builder.h>
7#include <iostream>
8#include <string>
9#include <llvm/Support/raw_ostream.h>
10#include <kernels/streamset.h>
11#include <cstdint>
12
13
14using namespace llvm;
15using namespace kernel;
16using namespace std;
17
18namespace kernel {
19    LZParabixLiteralDecoderKernel::LZParabixLiteralDecoderKernel(const std::unique_ptr<kernel::KernelBuilder> &b)
20            : SegmentOrientedKernel("LZParabixLiteralDecoderKernel",
21            // Inputs
22                                    {
23                                            Binding{b->getStreamSetTy(1, 8), "byteStream", BoundedRate(0, 1)},
24
25                                            // block data
26                                            Binding{b->getStreamSetTy(1, 64), "blockStart", BoundedRate(0, 1), AlwaysConsume()},
27                                            Binding{b->getStreamSetTy(1, 64), "blockEnd", RateEqualTo("blockStart"), AlwaysConsume()}
28
29
30                                    },
31            //Outputs
32                                    {
33                                            Binding{b->getStreamSetTy(8, 1), "literalBitStream", BoundedRate(0, 1)},
34                                    },
35            //Arguments
36                                    {
37                                            Binding{b->getSizeTy(), "fileSize"}
38                                    },
39                                    {},
40            //Internal states:
41                                    {
42                                            Binding{b->getInt64Ty(), "outputPos"},
43
44                                    })
45    {
46        this->setStride(4 * 1024 * 1024);
47        addAttribute(MustExplicitlyTerminate());
48    }
49
50    void LZParabixLiteralDecoderKernel::generateDoSegmentMethod(const std::unique_ptr<KernelBuilder> &b) {
51
52        BasicBlock* exitBlock = b->CreateBasicBlock("exitBlock");
53        BasicBlock* blockEndConBlock = b->CreateBasicBlock("blockEndConBlock");
54
55        Value * blockDataIndex = b->getProcessedItemCount("blockStart");
56        Value * totalNumber = b->getAvailableItemCount("blockStart");
57
58        Value * lz4BlockEnd = this->generateLoadInt64NumberInput(b, "blockEnd", blockDataIndex);
59
60
61
62        b->CreateCondBr(b->CreateICmpULT(blockDataIndex, totalNumber), blockEndConBlock, exitBlock);
63
64        // ---- blockEndConBlock
65        b->SetInsertPoint(blockEndConBlock);
66
67        Value * blockStart = this->generateLoadInt64NumberInput(b, "blockStart", blockDataIndex);
68        BasicBlock * processBlock = b->CreateBasicBlock("processBlock");
69
70        b->CreateBr(processBlock);
71
72        // ---- processBlock
73        b->SetInsertPoint(processBlock);
74
75        Value* isTerminal = b->CreateICmpEQ(lz4BlockEnd, b->getScalarField("fileSize"));
76        b->setTerminationSignal(isTerminal);
77
78        Value* newlyProduced = this->processBlock(b, blockStart);
79
80        Value * newBlockDataIndex = b->CreateAdd(blockDataIndex, b->getInt64(1));
81
82        b->setProcessedItemCount("blockStart", newBlockDataIndex);
83        b->setProcessedItemCount("byteStream", lz4BlockEnd);
84        b->setProducedItemCount("literalBitStream", b->CreateAdd(b->getProducedItemCount("literalBitStream"), newlyProduced));
85
86        b->CreateBr(exitBlock);
87
88        // ---- ExitBlock
89        b->SetInsertPoint(exitBlock);
90    }
91
92    llvm::Value* LZParabixLiteralDecoderKernel::generateLoadInt64NumberInput(const std::unique_ptr<KernelBuilder> &iBuilder,
93                                                                  std::string inputBufferName, llvm::Value *globalOffset) {
94
95        Value * capacity = iBuilder->getCapacity(inputBufferName);
96        Value * processed = iBuilder->getProcessedItemCount(inputBufferName);
97        processed = iBuilder->CreateAnd(processed, iBuilder->CreateNeg(capacity));
98        Value * offset = iBuilder->CreateSub(globalOffset, processed);
99        Value * valuePtr = iBuilder->getRawInputPointer(inputBufferName, offset);
100        return iBuilder->CreateLoad(valuePtr);
101    }
102
103    llvm::Value* LZParabixLiteralDecoderKernel::processBlock(const std::unique_ptr<KernelBuilder> &b, llvm::Value* blockStart) {
104        Value* blockBasePtr = b->getRawInputPointer("byteStream", blockStart);
105        Value* literalLength = b->CreateLoad(b->CreatePointerCast(blockBasePtr, b->getInt32Ty()->getPointerTo()));
106        literalLength = b->CreateZExtOrBitCast(literalLength, b->getSizeTy());
107        Value* literalBasePtr = b->CreateGEP(blockBasePtr, b->getSize(4));
108
109
110        Value* outputBasePtr = b->CreatePointerCast(b->getRawOutputPointer("literalBitStream", b->getSize(0)), b->getInt8PtrTy());
111
112        Value* outputPos = b->getProducedItemCount("literalBitStream");
113        Value* outputCapacity = b->getCapacity("literalBitStream");
114        Value* outputPosRem = b->CreateURem(outputPos, outputCapacity);
115
116        Value* remainingOutputSpace = b->CreateSub(outputCapacity, outputPosRem);
117
118
119        Value* copyLength1 = b->CreateUMin(remainingOutputSpace, literalLength);
120        Value* copyLength2 = b->CreateSub(literalLength, copyLength1);
121
122
123        b->CreateMemCpy(
124                b->CreateGEP(outputBasePtr, outputPosRem),
125                literalBasePtr,
126                copyLength1,
127                1
128        );
129
130        b->CreateMemCpy(
131                outputBasePtr,
132                b->CreateGEP(literalBasePtr, copyLength1),
133                copyLength2,
134                1
135        );
136
137        return literalLength;
138    }
139
140
141}
Note: See TracBrowser for help on using the repository browser.