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

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

Continued refactoring work. PabloKernel? now abstract base type with a 'generatePabloMethod' hook to generate Pablo code.

File size: 4.3 KB
RevLine 
[5057]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
[5062]9#include <kernels/kernel.h>
[5283]10#include <pablo/pabloAST.h>
[5217]11#include <pablo/symbol_generator.h>
[5230]12#include <util/slab_allocator.h>
[5283]13#include <llvm/ADT/StringRef.h>
[5371]14#include <boost/container/flat_map.hpp>
[5283]15
[5267]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; }
[5057]24
25namespace pablo {
26
[5283]27class PabloKernel : public kernel::BlockOrientedKernel, public PabloAST {
[5062]28
[5217]29    friend class PabloCompiler;
30    friend class PabloBlock;
31    friend class CarryManager;
32
[5057]33public:
[5217]34
[5240]35    using Allocator = SlabAllocator<PabloAST *>;
[5230]36
[5283]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
[5436]47    PabloKernel(const std::unique_ptr<kernel::KernelBuilder> & builder, std::string kernelName,
[5310]48                std::vector<Binding> stream_inputs = {},
49                std::vector<Binding> stream_outputs = {},
50                std::vector<Binding> scalar_parameters = {},
51                std::vector<Binding> scalar_outputs = {});
[5299]52
[5246]53    virtual ~PabloKernel();
[5202]54
[5435]55    PabloBlock * getEntryBlock() const {
[5217]56        return mEntryBlock;
57    }
58
59    PabloBlock * setEntryBlock(PabloBlock * entryBlock) {
60        assert (entryBlock);
61        std::swap(mEntryBlock, entryBlock);
62        return entryBlock;
63    }
[5299]64   
[5398]65    Var * getInputStreamVar(const std::string & name);
[5217]66
67    Var * getInput(const unsigned index) {
68        return mInputs[index];
69    }
70
71    const Var * getInput(const unsigned index) const {
72        return mInputs[index];
73    }
74
[5267]75    Var * addInput(const std::string & name, llvm::Type * const type);
[5217]76
77    unsigned getNumOfInputs() const {
78        return mInputs.size();
79    }
[5299]80   
[5398]81    Var * getOutputStreamVar(const std::string & name);
[5300]82   
[5398]83    Var * getOutputScalarVar(const std::string & name);
[5217]84
85    Var * getOutput(const unsigned index) {
86        return mOutputs[index];
87    }
88
89    const Var * getOutput(const unsigned index) const {
90        return mOutputs[index];
91    }
92
[5267]93    Var * addOutput(const std::string & name, llvm::Type * const type);
[5217]94
95    unsigned getNumOfOutputs() const {
96        return mOutputs.size();
97    }
98
[5283]99    Var * makeVariable(String * name, llvm::Type * const type);
[5217]100
101    Var * getVariable(const unsigned index) {
102        return mVariables[index];
103    }
104
105    unsigned getNumOfVariables() const {
106        return mVariables.size();
107    }
108
[5267]109    Zeroes * getNullValue(llvm::Type * const type);
[5217]110
[5267]111    Ones * getAllOnesValue(llvm::Type * const type);
[5217]112
113    inline SymbolGenerator * getSymbolTable() const {
114        return mSymbolTable;
115    }
116
[5310]117    void * operator new (std::size_t size) noexcept {
118        return std::malloc(size);
119    }
120
[5417]121    void operator delete(void* ptr) noexcept {
122        std::free(ptr);
123    }
124
[5074]125protected:
[5217]126
[5436]127    virtual void generatePabloMethod() = 0;
128
129    String * makeName(const llvm::StringRef & prefix) const;
130
131    Integer * getInteger(const int64_t value) const;
132
[5062]133    // A custom method for preparing kernel declarations is needed,
134    // so that the carry data requirements may be accommodated before
135    // finalizing the KernelStateType.
[5436]136    void prepareKernel() final;
[5057]137
[5436]138    void generateDoBlockMethod() final;
[5285]139
[5057]140    // The default method for Pablo final block processing sets the
141    // EOFmark bit and then calls the standard DoBlock function.
142    // This may be overridden for specialized processing.
[5436]143    void generateFinalBlockMethod(llvm::Value * remainingBytes) final;
[5059]144
[5217]145private:
146
[5230]147    Allocator                       mAllocator;
[5217]148    PabloCompiler * const           mPabloCompiler;
149    SymbolGenerator *               mSymbolTable;
150    PabloBlock *                    mEntryBlock;
[5230]151
[5217]152    std::vector<Var *>              mInputs;
153    std::vector<Var *>              mOutputs;
154    std::vector<PabloAST *>         mConstants;
155    std::vector<Var *>              mVariables;
[5300]156    boost::container::flat_map<std::string, Var *> mScalarOutputNameMap;
[5057]157};
[5217]158
[5057]159}
[5217]160
[5057]161#endif // PABLO_KERNEL_H
Note: See TracBrowser for help on using the repository browser.