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

Last change on this file since 5836 was 5836, checked in by nmedfort, 15 months ago

Added PabloBlock/Builder? createScope() methods + minor code changes.

File size: 5.7 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    Var * getInput(const unsigned index) {
67        assert (index < mInputs.size() && mInputs[index]);
68        return mInputs[index];
69    }
70
71    const Var * getInput(const unsigned index) const {
72        assert (index < mInputs.size() && mInputs[index]);
73        return mInputs[index];
74    }
75
76    unsigned getNumOfInputs() const {
77        return mInputs.size();
78    }
79   
80    Var * getOutputStreamVar(const std::string & name);
81   
82    Var * getOutputScalarVar(const std::string & name);
83
84    Var * getOutput(const unsigned index) {
85        assert (index < mOutputs.size() && mOutputs[index]);
86        return mOutputs[index];
87    }
88
89    const Var * getOutput(const unsigned index) const {
90        assert (index < mOutputs.size() && mOutputs[index]);
91        return mOutputs[index];
92    }
93
94    unsigned getNumOfOutputs() const {
95        return mOutputs.size();
96    }
97
98    Var * getVariable(const unsigned index) {
99        assert (index < mVariables.size() && mVariables[index]);
100        return mVariables[index];
101    }
102
103    unsigned getNumOfVariables() const {
104        return mVariables.size();
105    }
106
107    Zeroes * getNullValue(llvm::Type * const type);
108
109    Ones * getAllOnesValue(llvm::Type * const type);
110
111    inline SymbolGenerator * getSymbolTable() const {
112        return mSymbolTable;
113    }
114
115    void * operator new (std::size_t size) noexcept {
116        return std::malloc(size);
117    }
118
119    void operator delete(void* ptr) noexcept {
120        std::free(ptr);
121    }
122
123    String * makeName(const llvm::StringRef & prefix) const;
124
125    Integer * getInteger(const int64_t value) const;
126
127    llvm::StructType * getCarryDataTy() const {
128        return mCarryDataTy;
129    }
130
131    llvm::LLVMContext & getContext() const {
132        assert (mContext);
133        return *mContext;
134    }
135
136protected:
137
138    PabloKernel(const std::unique_ptr<kernel::KernelBuilder> & builder,
139                std::string && kernelName,
140                std::vector<kernel::Binding> stream_inputs = {},
141                std::vector<kernel::Binding> stream_outputs = {},
142                std::vector<kernel::Binding> scalar_parameters = {},
143                std::vector<kernel::Binding> scalar_outputs = {});
144
145    virtual void generatePabloMethod() = 0;
146
147    llvm::IntegerType * getSizeTy() const {
148        assert (mSizeTy); return mSizeTy;
149    }
150
151    llvm::VectorType * getStreamTy() const {
152        assert (mStreamTy); return mStreamTy;
153    }
154
155    llvm::IntegerType * getInt1Ty() const;
156
157    void setCarryDataTy(llvm::StructType * const carryDataTy) {
158        mCarryDataTy = carryDataTy;
159    }
160
161    Var * makeVariable(const String * name, llvm::Type * const type);
162
163    // A custom method for preparing kernel declarations is needed,
164    // so that the carry data requirements may be accommodated before
165    // finalizing the KernelStateType.
166    void addInternalKernelProperties(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) final;
167
168private:
169
170    void generateDoBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder) final;
171
172    // The default method for Pablo final block processing sets the
173    // EOFmark bit and then calls the standard DoBlock function.
174    // This may be overridden for specialized processing.
175    void generateFinalBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder, llvm::Value * remainingBytes) final;
176
177    void generateFinalizeMethod(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) final;
178
179    #if 0
180    void beginConditionalRegion(const std::unique_ptr<KernelBuilder> & b) final;
181    #endif
182
183private:
184
185    Allocator                       mAllocator;
186    PabloCompiler *                 mPabloCompiler;
187    SymbolGenerator *               mSymbolTable;
188    PabloBlock *                    mEntryScope;
189    llvm::IntegerType *             mSizeTy;
190    llvm::VectorType *              mStreamTy;
191    llvm::StructType *              mCarryDataTy;
192    llvm::LLVMContext *             mContext;
193
194    std::vector<Var *>              mInputs;
195    std::vector<Var *>              mOutputs;
196    std::vector<PabloAST *>         mConstants;
197    std::vector<Var *>              mVariables;
198    std::vector<Var *>              mScalarOutputVars;
199};
200
201}
202
203#endif // PABLO_KERNEL_H
Note: See TracBrowser for help on using the repository browser.