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

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

Partial removal of BlockNo?

File size: 3.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
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    virtual ~PabloKernel();
50
51    PabloBlock * getEntryBlock() {
52        return mEntryBlock;
53    }
54
55    const PabloBlock * getEntryBlock() const {
56        return mEntryBlock;
57    }
58
59    PabloBlock * setEntryBlock(PabloBlock * entryBlock) {
60        assert (entryBlock);
61        std::swap(mEntryBlock, entryBlock);
62        return entryBlock;
63    }
64
65    Var * getInput(const unsigned index) {
66        return mInputs[index];
67    }
68
69    const Var * getInput(const unsigned index) const {
70        return mInputs[index];
71    }
72
73    Var * addInput(const std::string & name, llvm::Type * const type);
74
75    unsigned getNumOfInputs() const {
76        return mInputs.size();
77    }
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
111protected:
112
113    // A custom method for preparing kernel declarations is needed,
114    // so that the carry data requirements may be accommodated before
115    // finalizing the KernelStateType.
116    void prepareKernel()  override final;
117
118    void generateDoBlockMethod() override final;
119
120    // The default method for Pablo final block processing sets the
121    // EOFmark bit and then calls the standard DoBlock function.
122    // This may be overridden for specialized processing.
123    virtual void generateFinalBlockMethod(llvm::Value * remainingBytes) override final;
124
125    inline String * makeName(const llvm::StringRef & prefix) const {
126        return mSymbolTable->makeString(prefix, iBuilder);
127    }
128
129    inline Integer * getInteger(const int64_t value) const {
130        return mSymbolTable->getInteger(value, iBuilder);
131    }
132
133private:
134
135    Allocator                       mAllocator;
136    PabloCompiler * const           mPabloCompiler;
137    SymbolGenerator *               mSymbolTable;
138    PabloBlock *                    mEntryBlock;
139
140    std::vector<Var *>              mInputs;
141    std::vector<Var *>              mOutputs;
142    std::vector<PabloAST *>         mConstants;
143    std::vector<Var *>              mVariables;
144
145};
146
147}
148
149#endif // PABLO_KERNEL_H
Note: See TracBrowser for help on using the repository browser.