Ignore:
Timestamp:
Nov 18, 2016, 1:46:55 PM (2 years ago)
Author:
nmedfort
Message:

Merged PabloFunction? and PabloKernel? classes. Updated projects where necessary.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/pablo_kernel.h

    r5202 r5217  
    88
    99#include <kernels/kernel.h>
    10 #include <IDISA/idisa_builder.h>
    11 #include <pablo/function.h>
     10#include <pablo/symbol_generator.h>
     11
     12namespace IDISA {
     13class IDISA_Builder;
     14}
    1215
    1316namespace pablo {
    1417   
    15 class PabloCompiler; class CarryManager;
    16 
     18class PabloCompiler;
     19class PabloBlock;
     20class PabloAST;
     21class CarryManager;
     22class Var;
     23class Zeroes;
     24class Ones;
     25class String;
     26class Integer;
    1727
    1828class PabloKernel : public kernel::KernelBuilder {
     29
     30    friend class PabloCompiler;
     31    friend class PabloBlock;
     32    friend class CarryManager;
     33
    1934public:
    20     PabloKernel(IDISA::IDISA_Builder * builder, std::string kernelName, PabloFunction * function);
     35
     36    PabloKernel(IDISA::IDISA_Builder * builder, const std::string & kernelName);
    2137    // At present only population count accumulator are supported,
    2238    // using the pablo.Count operation.
     
    2440    ~PabloKernel();
    2541
     42    PabloBlock * getEntryBlock() {
     43        return mEntryBlock;
     44    }
     45
     46    const PabloBlock * getEntryBlock() const {
     47        return mEntryBlock;
     48    }
     49
     50    PabloBlock * setEntryBlock(PabloBlock * entryBlock) {
     51        assert (entryBlock);
     52        std::swap(mEntryBlock, entryBlock);
     53        return entryBlock;
     54    }
     55
     56    Var * getInput(const unsigned index) {
     57        return mInputs[index];
     58    }
     59
     60    const Var * getInput(const unsigned index) const {
     61        return mInputs[index];
     62    }
     63
     64    Var * addInput(const std::string name, Type * const type);
     65
     66    unsigned getNumOfInputs() const {
     67        return mInputs.size();
     68    }
     69
     70    Var * getOutput(const unsigned index) {
     71        return mOutputs[index];
     72    }
     73
     74    const Var * getOutput(const unsigned index) const {
     75        return mOutputs[index];
     76    }
     77
     78    Var * addOutput(const std::string name, Type * const type);
     79
     80    unsigned getNumOfOutputs() const {
     81        return mOutputs.size();
     82    }
     83
     84    Var * makeVariable(PabloAST * name, Type * const type);
     85
     86    Var * getVariable(const unsigned index) {
     87        return mVariables[index];
     88    }
     89
     90    unsigned getNumOfVariables() const {
     91        return mVariables.size();
     92    }
     93
     94    Zeroes * getNullValue(Type * const type);
     95
     96    Ones * getAllOnesValue(Type * const type);
     97
     98    inline SymbolGenerator * getSymbolTable() const {
     99        return mSymbolTable;
     100    }
     101
    26102protected:
     103
    27104    // A custom method for preparing kernel declarations is needed,
    28105    // so that the carry data requirements may be accommodated before
     
    36113    // This may be overridden for specialized processing.
    37114    virtual void generateFinalBlockMethod() override;
    38    
    39     PabloFunction * mPabloFunction;
    40    
    41     PabloCompiler * mPabloCompiler;
    42115
    43     friend class PabloCompiler;
    44     friend class CarryManager;
     116    inline String * getName(const std::string & name) const {
     117        return mSymbolTable->get(name);
     118    }
     119
     120    inline String * makeName(const std::string & prefix) const {
     121        return mSymbolTable->make(prefix);
     122    }
     123
     124    inline Integer * getInteger(const int64_t value) const {
     125        return mSymbolTable->getInteger(value, iBuilder);
     126    }
     127
     128private:
     129
     130    PabloCompiler * const           mPabloCompiler;
     131    SymbolGenerator *               mSymbolTable;
     132    PabloBlock *                    mEntryBlock;
     133    std::vector<Var *>              mInputs;
     134    std::vector<Var *>              mOutputs;
     135    std::vector<PabloAST *>         mConstants;
     136    std::vector<Var *>              mVariables;
     137
    45138};
     139
    46140}
     141
    47142#endif // PABLO_KERNEL_H
Note: See TracChangeset for help on using the changeset viewer.