source: icGREP/icgrep-devel/icgrep/pablo/pablo_kernel.h @ 6228

Last change on this file since 6228 was 6228, checked in by nmedfort, 10 months ago

redesign of PopCount? calculation + mem leak fix

File size: 5.8 KB
Line 
1/*
2 *  Copyright (c) 2016 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 */
5
6#ifndef PABLO_KERNEL_H
7#define PABLO_KERNEL_H
8
9#include <kernels/kernel.h>
10#include <pablo/pabloAST.h>
11#include <pablo/symbol_generator.h>
12#include <util/slab_allocator.h>
13#include <llvm/ADT/StringRef.h>
14
15namespace llvm { class Type; }
16namespace llvm { class VectorType; }
17
18namespace pablo { class Integer; }
19namespace pablo { class Ones; }
20namespace pablo { class PabloBlock; }
21namespace pablo { class PabloCompiler; }
22namespace pablo { class String; }
23namespace pablo { class Var; }
24namespace pablo { class Zeroes; }
25
26namespace pablo {
27
28class PabloKernel : public kernel::BlockOrientedKernel, public PabloAST {
29
30    friend class PabloCompiler;
31    friend class PabloBlock;
32    friend class CarryManager;
33    friend class CarryPackManager;
34    friend class ParabixObjectCache;
35
36public:
37
38    using KernelBuilder = kernel::KernelBuilder;
39
40    using Allocator = SlabAllocator<PabloAST *>;
41
42    static inline bool classof(const PabloAST * e) {
43        return e->getClassTypeId()  == PabloAST::ClassTypeId::Kernel;
44    }
45    static inline bool classof(const PabloKernel *) {
46        return true;
47    }
48    static inline bool classof(const void *) {
49        return false;
50    }
51
52    virtual ~PabloKernel();
53
54    PabloBlock * getEntryScope() const {
55        return mEntryScope;
56    }
57
58    PabloBlock * setEntryScope(PabloBlock * entryBlock) {
59        assert (entryBlock);
60        std::swap(mEntryScope, entryBlock);
61        return entryBlock;
62    }
63
64    Var * getInputStreamVar(const std::string & name);
65
66    std::vector<PabloAST *> getInputStreamSet(const std::string & name);
67
68    Var * getInput(const unsigned index) {
69        assert (index < mInputs.size() && mInputs[index]);
70        return mInputs[index];
71    }
72
73    const Var * getInput(const unsigned index) const {
74        assert (index < mInputs.size() && mInputs[index]);
75        return mInputs[index];
76    }
77
78    unsigned getNumOfInputs() const {
79        return mInputs.size();
80    }
81
82    Var * getOutputStreamVar(const std::string & name);
83
84    Var * getOutputScalarVar(const std::string & name);
85
86    Var * getOutput(const unsigned index) {
87        assert (index < mOutputs.size() && mOutputs[index]);
88        return mOutputs[index];
89    }
90
91    const Var * getOutput(const unsigned index) const {
92        assert (index < mOutputs.size() && mOutputs[index]);
93        return mOutputs[index];
94    }
95
96    unsigned getNumOfOutputs() const {
97        return mOutputs.size();
98    }
99
100    Var * getVariable(const unsigned index) {
101        assert (index < mVariables.size() && mVariables[index]);
102        return mVariables[index];
103    }
104
105    unsigned getNumOfVariables() const {
106        return mVariables.size();
107    }
108
109    Zeroes * getNullValue(llvm::Type * const type);
110
111    Ones * getAllOnesValue(llvm::Type * const type);
112
113    inline SymbolGenerator * getSymbolTable() const {
114        return mSymbolTable.get();
115    }
116
117    void * operator new (std::size_t size) noexcept {
118        return std::malloc(size);
119    }
120
121    void operator delete(void* ptr) noexcept {
122        std::free(ptr);
123    }
124
125    String * makeName(const llvm::StringRef & prefix) const;
126
127    Integer * getInteger(const int64_t value) const;
128
129    llvm::StructType * getCarryDataTy() const {
130        return mCarryDataTy;
131    }
132
133    llvm::LLVMContext & getContext() const {
134        assert (mContext);
135        return *mContext;
136    }
137
138protected:
139
140    PabloKernel(const std::unique_ptr<kernel::KernelBuilder> & builder,
141                std::string && kernelName,
142                std::vector<kernel::Binding> stream_inputs = {},
143                std::vector<kernel::Binding> stream_outputs = {},
144                std::vector<kernel::Binding> scalar_parameters = {},
145                std::vector<kernel::Binding> scalar_outputs = {});
146
147    virtual void generatePabloMethod() = 0;
148
149    llvm::IntegerType * getSizeTy() const {
150        assert (mSizeTy); return mSizeTy;
151    }
152
153    llvm::VectorType * getStreamTy() const {
154        assert (mStreamTy); return mStreamTy;
155    }
156
157    llvm::IntegerType * getInt1Ty() const;
158
159    void setCarryDataTy(llvm::StructType * const carryDataTy) {
160        mCarryDataTy = carryDataTy;
161    }
162
163    Var * makeVariable(const String * name, llvm::Type * const type);
164
165    // A custom method for preparing kernel declarations is needed,
166    // so that the carry data requirements may be accommodated before
167    // finalizing the KernelStateType.
168    void addInternalKernelProperties(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) final;
169
170private:
171
172    void generateDoBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder) final;
173
174    // The default method for Pablo final block processing sets the
175    // EOFmark bit and then calls the standard DoBlock function.
176    // This may be overridden for specialized processing.
177    void generateFinalBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder, llvm::Value * remainingBytes) final;
178
179    void generateFinalizeMethod(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) final;
180
181    #if 0
182    void beginConditionalRegion(const std::unique_ptr<KernelBuilder> & b) final;
183    #endif
184
185private:
186
187    Allocator                        mAllocator;
188    std::unique_ptr<PabloCompiler>   mPabloCompiler;
189    std::unique_ptr<SymbolGenerator> mSymbolTable;
190    PabloBlock *                     mEntryScope;
191    llvm::IntegerType *              mSizeTy;
192    llvm::VectorType *               mStreamTy;
193    llvm::StructType *               mCarryDataTy;
194    llvm::LLVMContext *              mContext;
195
196    std::vector<Var *>               mInputs;
197    std::vector<Var *>               mOutputs;
198    std::vector<PabloAST *>          mConstants;
199    std::vector<Var *>               mVariables;
200    std::vector<Var *>               mScalarOutputVars;
201};
202
203}
204
205#endif // PABLO_KERNEL_H
Note: See TracBrowser for help on using the repository browser.