source: icGREP/icgrep-devel/icgrep/kernels/kernel.h @ 4932

Last change on this file since 4932 was 4930, checked in by lindanl, 3 years ago

KernelBuilder? updates.

File size: 2.9 KB
Line 
1#ifndef KERNEL_H
2#define KERNEL_H
3/*
4 *  Copyright (c) 2016 International Characters.
5 *  This software is licensed to the public under the Open Software License 3.0.
6 */
7
8
9#include <IDISA/idisa_builder.h>
10#include <llvm/IR/Function.h>
11#include <llvm/IR/Module.h>
12
13namespace llvm {
14    class Value;
15    class Module;
16    class ExecutionEngine;
17    class VectorType;
18    class PointerType;
19    class Constant;
20    class FunctionType;
21    class Function;
22    class BasicBlock;
23    class Type;
24}
25
26using namespace llvm;
27
28typedef Value* valptr;
29
30struct Inputs {
31    std::vector<std::vector<valptr>> streams;
32    std::vector<valptr> scalars;
33};
34
35struct Outputs {
36    std::vector<valptr *> streams;
37    std::vector<valptr> accums;
38};
39
40class KernelBuilder{
41public:
42    // sets name & sets internal state to the kernel superclass state
43        KernelBuilder(std::string name, Module * m, IDISA::IDISA_Builder * b);
44        ~KernelBuilder();
45
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();
63
64    void changeKernelInternalState(int idx, Value * stateValue);
65    Value * getKernelInternalState(int idx);
66    Value * getKernelInternalStatePtr(int idx);
67
68private:
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};
93
94#endif // KERNEL_H
Note: See TracBrowser for help on using the repository browser.