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

Last change on this file since 5828 was 5828, checked in by nmedfort, 15 months ago

Pablo support for byte comparisions; LineFeed? kernel processes byte streams directly. Some clean up of PabloBuilder? functionality.

File size: 5.7 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>
14
[5267]15namespace llvm { class Type; }
[5706]16namespace llvm { class VectorType; }
17
[5267]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; }
[5057]25
26namespace pablo {
27
[5283]28class PabloKernel : public kernel::BlockOrientedKernel, public PabloAST {
[5062]29
[5217]30    friend class PabloCompiler;
31    friend class PabloBlock;
32    friend class CarryManager;
[5510]33    friend class CarryPackManager;
[5630]34    friend class ParabixObjectCache;
[5217]35
[5057]36public:
[5217]37
[5440]38    using KernelBuilder = kernel::KernelBuilder;
39
[5240]40    using Allocator = SlabAllocator<PabloAST *>;
[5230]41
[5283]42    static inline bool classof(const PabloAST * e) {
43        return e->getClassTypeId()  == PabloAST::ClassTypeId::Kernel;
44    }
45    static inline bool classof(const PabloKernel *) {
46        return true;
47    }
48    static inline bool classof(const void *) {
49        return false;
50    }
51
[5246]52    virtual ~PabloKernel();
[5202]53
[5435]54    PabloBlock * getEntryBlock() const {
[5217]55        return mEntryBlock;
56    }
57
58    PabloBlock * setEntryBlock(PabloBlock * entryBlock) {
59        assert (entryBlock);
60        std::swap(mEntryBlock, entryBlock);
61        return entryBlock;
62    }
[5299]63   
[5398]64    Var * getInputStreamVar(const std::string & name);
[5217]65
66    Var * getInput(const unsigned index) {
[5828]67        assert (index < mInputs.size() && mInputs[index]);
[5217]68        return mInputs[index];
69    }
70
71    const Var * getInput(const unsigned index) const {
[5828]72        assert (index < mInputs.size() && mInputs[index]);
[5217]73        return mInputs[index];
74    }
75
76    unsigned getNumOfInputs() const {
77        return mInputs.size();
78    }
[5299]79   
[5398]80    Var * getOutputStreamVar(const std::string & name);
[5300]81   
[5398]82    Var * getOutputScalarVar(const std::string & name);
[5217]83
84    Var * getOutput(const unsigned index) {
[5828]85        assert (index < mOutputs.size() && mOutputs[index]);
[5217]86        return mOutputs[index];
87    }
88
89    const Var * getOutput(const unsigned index) const {
[5828]90        assert (index < mOutputs.size() && mOutputs[index]);
[5217]91        return mOutputs[index];
92    }
93
94    unsigned getNumOfOutputs() const {
95        return mOutputs.size();
96    }
97
98    Var * getVariable(const unsigned index) {
[5828]99        assert (index < mVariables.size() && mVariables[index]);
[5217]100        return mVariables[index];
101    }
102
103    unsigned getNumOfVariables() const {
104        return mVariables.size();
105    }
106
[5267]107    Zeroes * getNullValue(llvm::Type * const type);
[5217]108
[5267]109    Ones * getAllOnesValue(llvm::Type * const type);
[5217]110
111    inline SymbolGenerator * getSymbolTable() const {
112        return mSymbolTable;
113    }
114
[5310]115    void * operator new (std::size_t size) noexcept {
116        return std::malloc(size);
117    }
118
[5417]119    void operator delete(void* ptr) noexcept {
120        std::free(ptr);
121    }
122
[5437]123    String * makeName(const llvm::StringRef & prefix) const;
124
125    Integer * getInteger(const int64_t value) const;
126
[5630]127    llvm::StructType * getCarryDataTy() const {
128        return mCarryDataTy;
129    }
130
[5828]131    llvm::LLVMContext & getContext() const {
132        assert (mContext);
133        return *mContext;
134    }
135
[5074]136protected:
[5217]137
[5454]138    PabloKernel(const std::unique_ptr<kernel::KernelBuilder> & builder,
139                std::string && kernelName,
[5706]140                std::vector<kernel::Binding> stream_inputs = {},
141                std::vector<kernel::Binding> stream_outputs = {},
142                std::vector<kernel::Binding> scalar_parameters = {},
143                std::vector<kernel::Binding> scalar_outputs = {});
[5437]144
[5436]145    virtual void generatePabloMethod() = 0;
146
[5446]147    llvm::IntegerType * getSizeTy() const {
148        assert (mSizeTy); return mSizeTy;
149    }
150
151    llvm::VectorType * getStreamTy() const {
152        assert (mStreamTy); return mStreamTy;
153    }
154
155    llvm::IntegerType * getInt1Ty() const;
156
[5630]157    void setCarryDataTy(llvm::StructType * const carryDataTy) {
158        mCarryDataTy = carryDataTy;
159    }
[5436]160
[5828]161    Var * makeVariable(String * name, llvm::Type * const type);
162
[5062]163    // A custom method for preparing kernel declarations is needed,
164    // so that the carry data requirements may be accommodated before
165    // finalizing the KernelStateType.
[5630]166    void addInternalKernelProperties(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) final;
[5057]167
[5630]168private:
169
[5440]170    void generateDoBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder) final;
[5285]171
[5057]172    // The default method for Pablo final block processing sets the
173    // EOFmark bit and then calls the standard DoBlock function.
174    // This may be overridden for specialized processing.
[5440]175    void generateFinalBlockMethod(const std::unique_ptr<KernelBuilder> & iBuilder, llvm::Value * remainingBytes) final;
[5059]176
[5486]177    void generateFinalizeMethod(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) final;
178
[5828]179    #if 0
180    void beginConditionalRegion(const std::unique_ptr<KernelBuilder> & b) final;
181    #endif
182
[5217]183private:
184
[5230]185    Allocator                       mAllocator;
[5828]186    PabloCompiler *                 mPabloCompiler;
[5217]187    SymbolGenerator *               mSymbolTable;
188    PabloBlock *                    mEntryBlock;
[5446]189    llvm::IntegerType *             mSizeTy;
190    llvm::VectorType *              mStreamTy;
[5630]191    llvm::StructType *              mCarryDataTy;
[5828]192    llvm::LLVMContext *             mContext;
193
[5217]194    std::vector<Var *>              mInputs;
195    std::vector<Var *>              mOutputs;
196    std::vector<PabloAST *>         mConstants;
197    std::vector<Var *>              mVariables;
[5828]198    std::vector<Var *>              mScalarOutputVars;
[5057]199};
[5217]200
[5057]201}
[5217]202
[5057]203#endif // PABLO_KERNEL_H
Note: See TracBrowser for help on using the repository browser.