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

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

Added enable asserts (-ea) command line flag + restructured BlockOrientedKernels? to allow for inlined code.

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