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

Last change on this file since 5454 was 5454, checked in by nmedfort, 2 years ago

Bug fix check in for DumpTrace?, compilation of DoBlock? / DoFinalBlock? functions. Pablo CodeMotionPass? optimized and enabled by default.

File size: 4.9 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 pablo { class Integer; }
18namespace pablo { class Ones; }
19namespace pablo { class PabloBlock; }
20namespace pablo { class PabloCompiler; }
21namespace pablo { class String; }
22namespace pablo { class Var; }
23namespace pablo { class Zeroes; }
24
25namespace pablo {
26
27class PabloKernel : public kernel::BlockOrientedKernel, public PabloAST {
28
29    friend class PabloCompiler;
30    friend class PabloBlock;
31    friend class CarryManager;
32
33public:
34
35    using KernelBuilder = kernel::KernelBuilder;
36
37    using Allocator = SlabAllocator<PabloAST *>;
38
39    static inline bool classof(const PabloAST * e) {
40        return e->getClassTypeId()  == PabloAST::ClassTypeId::Kernel;
41    }
42    static inline bool classof(const PabloKernel *) {
43        return true;
44    }
45    static inline bool classof(const void *) {
46        return false;
47    }
48
49    virtual ~PabloKernel();
50
51    PabloBlock * getEntryBlock() const {
52        return mEntryBlock;
53    }
54
55    PabloBlock * setEntryBlock(PabloBlock * entryBlock) {
56        assert (entryBlock);
57        std::swap(mEntryBlock, entryBlock);
58        return entryBlock;
59    }
60   
61    Var * getInputStreamVar(const std::string & name);
62
63    Var * getInput(const unsigned index) {
64        return mInputs[index];
65    }
66
67    const Var * getInput(const unsigned index) const {
68        return mInputs[index];
69    }
70
71    Var * addInput(const std::string & name, llvm::Type * const type);
72
73    unsigned getNumOfInputs() const {
74        return mInputs.size();
75    }
76   
77    Var * getOutputStreamVar(const std::string & name);
78   
79    Var * getOutputScalarVar(const std::string & name);
80
81    Var * getOutput(const unsigned index) {
82        return mOutputs[index];
83    }
84
85    const Var * getOutput(const unsigned index) const {
86        return mOutputs[index];
87    }
88
89    Var * addOutput(const std::string & name, llvm::Type * const type);
90
91    unsigned getNumOfOutputs() const {
92        return mOutputs.size();
93    }
94
95    Var * makeVariable(String * name, llvm::Type * const type);
96
97    Var * getVariable(const unsigned index) {
98        return mVariables[index];
99    }
100
101    unsigned getNumOfVariables() const {
102        return mVariables.size();
103    }
104
105    Zeroes * getNullValue(llvm::Type * const type);
106
107    Ones * getAllOnesValue(llvm::Type * const type);
108
109    inline SymbolGenerator * getSymbolTable() const {
110        return mSymbolTable;
111    }
112
113    void * operator new (std::size_t size) noexcept {
114        return std::malloc(size);
115    }
116
117    void operator delete(void* ptr) noexcept {
118        std::free(ptr);
119    }
120
121    String * makeName(const llvm::StringRef & prefix) const;
122
123    Integer * getInteger(const int64_t value) const;
124
125protected:
126
127    PabloKernel(const std::unique_ptr<kernel::KernelBuilder> & builder,
128                std::string && kernelName,
129                std::vector<Binding> stream_inputs = {},
130                std::vector<Binding> stream_outputs = {},
131                std::vector<Binding> scalar_parameters = {},
132                std::vector<Binding> scalar_outputs = {});
133
134    virtual void generatePabloMethod() = 0;
135
136    llvm::IntegerType * getSizeTy() const {
137        assert (mSizeTy); return mSizeTy;
138    }
139
140    llvm::VectorType * getStreamTy() const {
141        assert (mStreamTy); return mStreamTy;
142    }
143
144    llvm::IntegerType * getInt1Ty() const;
145
146private:
147
148    // A custom method for preparing kernel declarations is needed,
149    // so that the carry data requirements may be accommodated before
150    // finalizing the KernelStateType.
151    void prepareKernel(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) final;
152
153    void generateDoBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder) final;
154
155    // The default method for Pablo final block processing sets the
156    // EOFmark bit and then calls the standard DoBlock function.
157    // This may be overridden for specialized processing.
158    void generateFinalBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder, llvm::Value * remainingBytes) final;
159
160private:
161
162    Allocator                       mAllocator;
163    PabloCompiler * const           mPabloCompiler;
164    SymbolGenerator *               mSymbolTable;
165    PabloBlock *                    mEntryBlock;
166    llvm::IntegerType *             mSizeTy;
167    llvm::VectorType *              mStreamTy;
168    std::vector<Var *>              mInputs;
169    std::vector<Var *>              mOutputs;
170    std::vector<PabloAST *>         mConstants;
171    std::vector<Var *>              mVariables;
172    boost::container::flat_map<std::string, Var *> mScalarOutputNameMap;
173};
174
175}
176
177#endif // PABLO_KERNEL_H
Note: See TracBrowser for help on using the repository browser.