Ignore:
Timestamp:
Mar 7, 2016, 3:37:30 PM (3 years ago)
Author:
nmedfort
Message:

Initial modifications to Pablo Compiler and Kernel Builder to support circular buffers for Lookahead.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/kernels/kernel.h

    r4945 r4959  
    66 */
    77
    8 
    9 #include <IDISA/idisa_builder.h>
    10 #include <llvm/IR/Function.h>
    11 #include <llvm/IR/Module.h>
     8#include <string>
     9#include <vector>
    1210
    1311namespace llvm {
     
    2422}
    2523
    26 using namespace llvm;
     24namespace pablo {
     25    class PabloAST;
     26    class PabloFunction;
     27}
    2728
    28 typedef Value* valptr;
     29namespace IDISA {
     30    class IDISA_Builder;
     31}
    2932
    30 struct Inputs {
    31     std::vector<std::vector<valptr>> streams;
    32     std::vector<valptr> scalars;
     33class KernelBuilder {
     34
     35public:
     36    // sets name & sets internal state to the kernel superclass state
     37    KernelBuilder(std::string name, llvm::Module * m, IDISA::IDISA_Builder * b);
     38
     39    unsigned addInternalStateType(llvm::Type * type);
     40    void addOutputStream(const unsigned fields);
     41    void addOutputAccum(llvm::Type * t);
     42    void addInputStream(const unsigned fields, std::string name);
     43    void addInputScalar(llvm::Type * t, std::string name);
     44
     45    llvm::Function * prepareFunction();
     46
     47    void increment();
     48    void incrementCircularBuffer();
     49
     50    llvm::Value * getInputStream(const unsigned index, const unsigned streamOffset = 0);
     51    llvm::Value * getKernelState(const unsigned index, const unsigned streamOffset = 0);
     52    llvm::Value * getOutputStream(const unsigned index, const unsigned streamOffset = 0);
     53    llvm::Value * getOutputScalar(const unsigned index, const unsigned streamOffset = 0);
     54
     55    void finalize();
     56
     57    llvm::Value * generateKernelInstance();
     58        void generateInitCall();
     59    void generateDoBlockCall(llvm::Value * inputStreams);
     60
     61    unsigned getSegmentBlocks() const;
     62    llvm::Function * getDoBlockFunction() const;
     63    llvm::Type * getKernelStructType() const;
     64    llvm::Value * getKernelStructParam() const;
     65
     66    void setCircularBufferSize(const unsigned blocks);
     67    void setBlocksPerSegment(const unsigned blocks);
     68
     69    void setInternalState(const unsigned index, llvm::Value * const value);
     70    llvm::Value * getInternalState(const unsigned index);
     71
     72protected:
     73
     74    llvm::Value * getOffset(const unsigned offset);
     75
     76private:
     77    llvm::Module *                      mMod;
     78    IDISA::IDISA_Builder *              iBuilder;
     79    std::string                                                 mKernelName;
     80    llvm::Type *                        mBitBlockType;
     81    std::vector<llvm::Type *>                   mStates;
     82    std::vector<llvm::Type *>           mInputStreams;
     83    std::vector<llvm::Type *>           mOutputStreams;
     84    std::vector<llvm::Type *>           mInputScalars;
     85    std::vector<llvm::Type *>           mOutputAccums;
     86    std::vector<std::string>            mInputStreamNames;
     87    std::vector<std::string>            mInputScalarNames;
     88    llvm::Function*                                     mConstructor;
     89    llvm::Function*                                             mInitFunction;
     90    llvm::Function*                                             mFunction;
     91    unsigned                            mBlockSize;
     92    unsigned                            mBlocksPerSegment;
     93    unsigned                            mCircularBufferModulo;
     94    llvm::Type *                        mKernelStructType;
     95    llvm::Type *                        mInputStreamType;
     96    llvm::Type *                        mInputScalarType;
     97    llvm::Value *                       mInputParam;
     98    llvm::Value *                       mKernelStruct;
     99    llvm::Value *                       mKernelParam;
     100    unsigned                            mSegmentIndex;
     101    unsigned                            mStartIndex;
    33102};
    34103
    35 struct Outputs {
    36     std::vector<valptr *> streams;
    37     std::vector<valptr> accums;
    38 };
     104inline unsigned KernelBuilder::getSegmentBlocks() const {
     105    return mBlocksPerSegment;
     106}
    39107
    40 class KernelBuilder{
    41 public:
    42     // sets name & sets internal state to the kernel superclass state
    43         KernelBuilder(std::string name, Module * m, IDISA::IDISA_Builder * b);
    44         ~KernelBuilder();
     108inline llvm::Function * KernelBuilder::getDoBlockFunction() const {
     109    return mFunction;
     110}
    45111
    46         int extendKernelInternalStateType(Type * t);
    47         void addKernelOutputStream(int fw);
    48         void addKernelOutputAccum(Type * t);
    49         void addKernelInputStream(int fw, std::string name);
    50         void addKernelInputScalar(Type * t, std::string name);
    51     void PrepareDoBlockFunction();
    52         struct Inputs openDoBlock();
    53         void closeDoBlock(struct Outputs);
    54         void finalizeMethods();
    55         Value * generateKernelInstance();
    56         void generateInitCall();
    57         // void generateDoBlockCall(Value * inputStreams, Value * inputScalars);
    58     void generateDoBlockCall(Value * inputStreams);
    59     int getSegmentBlocks();
    60     Function * getDoBlockFunction();
    61     Type * getKernelStructType();
    62     Value * getKernelStructParam();
     112inline llvm::Type * KernelBuilder::getKernelStructType() const{
     113    return mKernelStructType;
     114}
    63115
    64     void changeKernelInternalState(Value * kernelStruct, int idx, Value * stateValue);
    65     Value * getKernelInternalState(Value * kernelStruct, int idx);
    66     Value * getKernelInternalStatePtr(Value * kernelStruct, int idx);
     116inline llvm::Value * KernelBuilder::getKernelStructParam() const {
     117    return mKernelParam;
     118}
    67119
    68 private:
    69         Module *                            mMod;
    70     IDISA::IDISA_Builder *              iBuilder;
    71     std::string                                                 mKernelName;
    72     int                                 mPredifinedStates;
    73     Type*                               mBitBlockType;
    74     std::vector<Type *>                                 mStates;
    75     std::vector<Type *>                 mInputStreams;
    76     std::vector<Type *>                 mOutputStreams;
    77     std::vector<Type *>                 mInputScalars;
    78     std::vector<Type *>                 mOutputAccums;
    79     std::vector<std::string>            mInputStreamNames;
    80     std::vector<std::string>            mInputScalarNames;
    81     Function*                                                   mConstructor;
    82     Function*                                                   mInitFunction;
    83     Function*                                                   mDoBlockFunction;
    84     int                                 mBufferSize;
    85     int                                 mBlockSize;
    86     int                                 mSegmentBlocks;
    87     Type *                              mKernelStructType;
    88     Type *                              mInputStreamType;   
    89     Type *                              mInputScalarType;
    90     Value*                              mKernelStruct;
    91     Value*                              mKernelStructParam;
    92 };
     120inline void KernelBuilder::setCircularBufferSize(const unsigned blocks) {
     121    mCircularBufferModulo = blocks;
     122}
     123
     124inline void KernelBuilder::setBlocksPerSegment(const unsigned blocks) {
     125    mBlocksPerSegment = blocks;
     126}
     127
     128inline void KernelBuilder::increment() {
     129    ++mSegmentIndex;
     130}
    93131
    94132#endif // KERNEL_H
Note: See TracChangeset for help on using the changeset viewer.