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

Last change on this file since 5706 was 5706, checked in by nmedfort, 17 months ago

First stage of MultiBlockKernel? and pipeline restructuring

File size: 5.3 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#include <boost/container/flat_map.hpp>
15
16namespace llvm { class Type; }
17namespace llvm { class VectorType; }
18
19namespace pablo { class Integer; }
20namespace pablo { class Ones; }
21namespace pablo { class PabloBlock; }
22namespace pablo { class PabloCompiler; }
23namespace pablo { class String; }
24namespace pablo { class Var; }
25namespace pablo { class Zeroes; }
26
27namespace pablo {
28
29class PabloKernel : public kernel::BlockOrientedKernel, public PabloAST {
30
31    friend class PabloCompiler;
32    friend class PabloBlock;
33    friend class CarryManager;
34    friend class CarryPackManager;
35    friend class ParabixObjectCache;
36
37public:
38
39    using KernelBuilder = kernel::KernelBuilder;
40
41    using Allocator = SlabAllocator<PabloAST *>;
42
43    static inline bool classof(const PabloAST * e) {
44        return e->getClassTypeId()  == PabloAST::ClassTypeId::Kernel;
45    }
46    static inline bool classof(const PabloKernel *) {
47        return true;
48    }
49    static inline bool classof(const void *) {
50        return false;
51    }
52
53    virtual ~PabloKernel();
54
55    PabloBlock * getEntryBlock() const {
56        return mEntryBlock;
57    }
58
59    PabloBlock * setEntryBlock(PabloBlock * entryBlock) {
60        assert (entryBlock);
61        std::swap(mEntryBlock, entryBlock);
62        return entryBlock;
63    }
64   
65    Var * getInputStreamVar(const std::string & name);
66
67    Var * getInput(const unsigned index) {
68        return mInputs[index];
69    }
70
71    const Var * getInput(const unsigned index) const {
72        return mInputs[index];
73    }
74
75    Var * addInput(const std::string & name, llvm::Type * const type);
76
77    unsigned getNumOfInputs() const {
78        return mInputs.size();
79    }
80   
81    Var * getOutputStreamVar(const std::string & name);
82   
83    Var * getOutputScalarVar(const std::string & name);
84
85    Var * getOutput(const unsigned index) {
86        return mOutputs[index];
87    }
88
89    const Var * getOutput(const unsigned index) const {
90        return mOutputs[index];
91    }
92
93    Var * addOutput(const std::string & name, llvm::Type * const type);
94
95    unsigned getNumOfOutputs() const {
96        return mOutputs.size();
97    }
98
99    Var * makeVariable(String * name, llvm::Type * const type);
100
101    Var * getVariable(const unsigned 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;
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
133protected:
134
135    PabloKernel(const std::unique_ptr<kernel::KernelBuilder> & builder,
136                std::string && kernelName,
137                std::vector<kernel::Binding> stream_inputs = {},
138                std::vector<kernel::Binding> stream_outputs = {},
139                std::vector<kernel::Binding> scalar_parameters = {},
140                std::vector<kernel::Binding> scalar_outputs = {});
141
142    virtual void generatePabloMethod() = 0;
143
144    llvm::IntegerType * getSizeTy() const {
145        assert (mSizeTy); return mSizeTy;
146    }
147
148    llvm::VectorType * getStreamTy() const {
149        assert (mStreamTy); return mStreamTy;
150    }
151
152    llvm::IntegerType * getInt1Ty() const;
153
154    void setCarryDataTy(llvm::StructType * const carryDataTy) {
155        mCarryDataTy = carryDataTy;
156    }
157
158    // A custom method for preparing kernel declarations is needed,
159    // so that the carry data requirements may be accommodated before
160    // finalizing the KernelStateType.
161    void addInternalKernelProperties(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) final;
162
163private:
164
165    void generateDoBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder) final;
166
167    // The default method for Pablo final block processing sets the
168    // EOFmark bit and then calls the standard DoBlock function.
169    // This may be overridden for specialized processing.
170    void generateFinalBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder, llvm::Value * remainingBytes) final;
171
172    void generateFinalizeMethod(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) final;
173
174private:
175
176    Allocator                       mAllocator;
177    PabloCompiler * const           mPabloCompiler;
178    SymbolGenerator *               mSymbolTable;
179    PabloBlock *                    mEntryBlock;
180    llvm::IntegerType *             mSizeTy;
181    llvm::VectorType *              mStreamTy;
182    llvm::StructType *              mCarryDataTy;
183    std::vector<Var *>              mInputs;
184    std::vector<Var *>              mOutputs;
185    std::vector<PabloAST *>         mConstants;
186    std::vector<Var *>              mVariables;
187    boost::container::flat_map<std::string, Var *> mScalarOutputNameMap;
188};
189
190}
191
192#endif // PABLO_KERNEL_H
Note: See TracBrowser for help on using the repository browser.