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

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

Minor correction to prevent editd from caching the pattern kernel.

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