source: icGREP/icgrep-devel/icgrep/kernels/interface.h @ 5941

Last change on this file since 5941 was 5941, checked in by xwa163, 13 months ago
  1. Add attributes to disable some features of multiblock kernel
  2. Fix bug for lz4d new approach in large data, pass all test cases
  3. Disable lz4d related test cases for old approach
File size: 6.7 KB
Line 
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 KERNEL_INTERFACE_H
7#define KERNEL_INTERFACE_H
8
9#include <kernels/processing_rate.h>
10#include <kernels/attributes.h>
11#include <llvm/Support/Compiler.h>
12#include <memory>
13#include <string>
14#include <vector>
15
16namespace IDISA { class IDISA_Builder; }
17namespace kernel { class Kernel; }
18namespace kernel { class KernelBuilder; }
19namespace llvm { class CallInst; }
20namespace llvm { class Function; }
21namespace llvm { class Value; }
22namespace llvm { class Module; }
23namespace llvm { class StructType; }
24namespace llvm { class Type; }
25
26namespace kernel {
27
28struct Binding : public AttributeSet {
29
30    Binding(llvm::Type * type, const std::string & name, ProcessingRate r = FixedRate(1))
31    : AttributeSet()
32    , mType(type), mName(name), mRate(std::move(r)) { }
33
34
35    Binding(llvm::Type * type, const std::string & name, ProcessingRate r, Attribute && attribute)
36    : AttributeSet(std::move(attribute))
37    , mType(type), mName(name), mRate(std::move(r)) { }
38
39
40    Binding(llvm::Type * type, const std::string & name, ProcessingRate r, std::initializer_list<Attribute> attributes)
41    : AttributeSet(attributes)
42    , mType(type), mName(name), mRate(std::move(r)) { }
43
44    llvm::Type * getType() const {
45        return mType;
46    }
47
48    const std::string & getName() const {
49        return mName;
50    }
51
52    const ProcessingRate & getRate() const {
53        return mRate;
54    }
55
56    ProcessingRate & getRate() {
57        return mRate;
58    }
59
60    bool isPrincipal() const {
61        return hasAttribute(AttributeId::Principal);
62    }
63
64    bool hasLookahead() const {
65        return hasAttribute(AttributeId::LookAhead);
66    }
67
68    bool isMisaligned() const {
69        return hasAttribute(AttributeId::Misaligned);
70    }
71
72    bool isSwizzled() const {
73        return hasAttribute(AttributeId::Swizzled);
74    }
75
76    bool isDisableTemporaryBuffer() const {
77        return hasAttribute(AttributeId::DisableTemporaryBuffer);
78    }
79
80    bool isDisableSufficientChecking() const {
81        return hasAttribute(AttributeId::DisableSufficientChecking);
82    }
83
84    bool isDisableAvailableItemCountAdjustment() const {
85        return hasAttribute(AttributeId::DisableAvailableItemCountAdjustment);
86    }
87
88    unsigned const getLookahead() const {
89        return findAttribute(AttributeId::LookAhead).amount();
90    }
91
92    bool nonDeferred() const {
93        return !hasAttribute(AttributeId::Deferred);
94    }
95
96private:
97    llvm::Type * const          mType;
98    const std::string           mName;
99    ProcessingRate              mRate;
100};
101
102using Bindings = std::vector<Binding>;
103
104class KernelInterface : public AttributeSet {
105public:
106    /*
107     
108     This class defines the methods to be used to generate the code 
109     necessary for declaring, allocating, calling and synchronizing
110     kernels.   The methods to be used for constructing kernels are defined
111     within the KernelBuilder class of kernel.h
112     
113     */
114   
115    const std::string & getName() const {
116        return mKernelName;
117    }
118       
119    virtual bool isCachable() const = 0;
120
121    virtual std::string makeSignature(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
122
123    const std::vector<Binding> & getStreamInputs() const {
124        return mStreamSetInputs;
125    }
126
127    const Binding & getStreamInput(const unsigned i) const {
128        assert (i < getNumOfStreamInputs());
129        return mStreamSetInputs[i];
130    }
131
132    unsigned getNumOfStreamInputs() const {
133        return mStreamSetInputs.size();
134    }
135
136    const std::vector<Binding> & getStreamOutputs() const {
137        return mStreamSetOutputs;
138    }
139
140    unsigned getNumOfStreamOutputs() const {
141        return mStreamSetOutputs.size();
142    }
143
144    const Binding & getStreamOutput(const unsigned i) const {
145        assert (i < getNumOfStreamOutputs());
146        return mStreamSetOutputs[i];
147    }
148
149    const std::vector<Binding> & getScalarInputs() const {
150        return mScalarInputs;
151    }
152
153    const Binding & getScalarInput(const unsigned i) const {
154        return mScalarInputs[i];
155    }
156
157    const std::vector<Binding> & getScalarOutputs() const {
158        return mScalarOutputs;
159    }
160
161    const Binding & getScalarOutput(const unsigned i) const {
162        return mScalarOutputs[i];
163    }
164
165    // Add ExternalLinkage method declarations for the kernel to a given client module.
166    void addKernelDeclarations(const std::unique_ptr<kernel::KernelBuilder> & idb);
167
168    virtual void linkExternalMethods(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
169
170    virtual llvm::Value * createInstance(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
171
172    virtual void initializeInstance(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
173
174    virtual void finalizeInstance(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
175
176    void setInitialArguments(std::vector<llvm::Value *> && args) {
177        mInitialArguments.swap(args);
178    }
179
180    llvm::Value * getInstance() const {
181        return mKernelInstance;
182    }
183
184    void setInstance(llvm::Value * const instance);
185
186    bool hasPrincipalItemCount() const {
187        return mHasPrincipalItemCount;
188    }
189
190protected:
191
192    llvm::Function * getInitFunction(llvm::Module * const module) const;
193
194    llvm::Function * getDoSegmentFunction(llvm::Module * const module) const;
195
196    llvm::Function * getTerminateFunction(llvm::Module * const module) const;
197
198    llvm::CallInst * makeDoSegmentCall(KernelBuilder & idb, const std::vector<llvm::Value *> & args) const;
199
200    KernelInterface(const std::string && kernelName,
201                    Bindings && stream_inputs,
202                    Bindings && stream_outputs,
203                    Bindings && scalar_inputs,
204                    Bindings && scalar_outputs,
205                    Bindings && internal_scalars)
206    : mKernelInstance(nullptr)
207    , mModule(nullptr)
208    , mKernelStateType(nullptr)
209    , mHasPrincipalItemCount(false)
210    , mKernelName(kernelName)
211    , mStreamSetInputs(stream_inputs)
212    , mStreamSetOutputs(stream_outputs)
213    , mScalarInputs(scalar_inputs)
214    , mScalarOutputs(scalar_outputs)
215    , mInternalScalars(internal_scalars) {
216
217    }
218   
219protected:
220
221    llvm::Value *                   mKernelInstance;
222    llvm::Module *                  mModule;
223    llvm::StructType *              mKernelStateType;
224    bool                            mHasPrincipalItemCount;
225    const std::string               mKernelName;
226    std::vector<llvm::Value *>      mInitialArguments;
227    Bindings                        mStreamSetInputs;
228    Bindings                        mStreamSetOutputs;
229    Bindings                        mScalarInputs;
230    Bindings                        mScalarOutputs;
231    Bindings                        mInternalScalars;
232};
233
234}
235
236#endif
Note: See TracBrowser for help on using the repository browser.