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

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

Back up check-in. Should have no effect on current programs.

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