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

Last change on this file since 5299 was 5299, checked in by cameron, 3 years ago

Ability to set input/output signatures for Pablo functions in the constructor

File size: 4.2 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
15namespace IDISA { class IDISA_Builder; }
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    PabloKernel(IDISA::IDISA_Builder * builder, std::string kernelName);
48   
49    PabloKernel(IDISA::IDISA_Builder * builder, std::string kernelName,                     
50                    std::vector<Binding> && stream_inputs,
51                    std::vector<Binding> && stream_outputs,
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 * getInputSet(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 * getOutputSet(std::string inputSetName);
87
88    Var * getOutput(const unsigned index) {
89        return mOutputs[index];
90    }
91
92    const Var * getOutput(const unsigned index) const {
93        return mOutputs[index];
94    }
95
96    Var * addOutput(const std::string & name, llvm::Type * const type);
97
98    unsigned getNumOfOutputs() const {
99        return mOutputs.size();
100    }
101
102    Var * makeVariable(String * name, llvm::Type * const type);
103
104    Var * getVariable(const unsigned index) {
105        return mVariables[index];
106    }
107
108    unsigned getNumOfVariables() const {
109        return mVariables.size();
110    }
111
112    Zeroes * getNullValue(llvm::Type * const type);
113
114    Ones * getAllOnesValue(llvm::Type * const type);
115
116    inline SymbolGenerator * getSymbolTable() const {
117        return mSymbolTable;
118    }
119
120protected:
121
122    // A custom method for preparing kernel declarations is needed,
123    // so that the carry data requirements may be accommodated before
124    // finalizing the KernelStateType.
125    void prepareKernel()  override final;
126
127    void generateDoBlockMethod() override final;
128
129    // The default method for Pablo final block processing sets the
130    // EOFmark bit and then calls the standard DoBlock function.
131    // This may be overridden for specialized processing.
132    virtual void generateFinalBlockMethod(llvm::Value * remainingBytes) override final;
133
134    inline String * makeName(const llvm::StringRef & prefix) const {
135        return mSymbolTable->makeString(prefix, iBuilder);
136    }
137
138    inline Integer * getInteger(const int64_t value) const {
139        return mSymbolTable->getInteger(value, iBuilder);
140    }
141
142private:
143
144    Allocator                       mAllocator;
145    PabloCompiler * const           mPabloCompiler;
146    SymbolGenerator *               mSymbolTable;
147    PabloBlock *                    mEntryBlock;
148
149    std::vector<Var *>              mInputs;
150    std::vector<Var *>              mOutputs;
151    std::vector<PabloAST *>         mConstants;
152    std::vector<Var *>              mVariables;
153
154};
155
156}
157
158#endif // PABLO_KERNEL_H
Note: See TracBrowser for help on using the repository browser.