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

Last change on this file since 5967 was 5967, checked in by nmedfort, 12 months ago

Updated LZ4SwizzledMatchCopy + minor changes

File size: 6.4 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 isDisableSufficientChecking() const {
77        return hasAttribute(AttributeId::DisableSufficientChecking);
78    }
79
80    unsigned const getLookahead() const {
81        return findAttribute(AttributeId::LookAhead).amount();
82    }
83
84    bool nonDeferred() const {
85        return !hasAttribute(AttributeId::Deferred);
86    }
87
88private:
89    llvm::Type * const          mType;
90    const std::string           mName;
91    ProcessingRate              mRate;
92};
93
94using Bindings = std::vector<Binding>;
95
96class KernelInterface : public AttributeSet {
97public:
98    /*
99     
100     This class defines the methods to be used to generate the code 
101     necessary for declaring, allocating, calling and synchronizing
102     kernels.   The methods to be used for constructing kernels are defined
103     within the KernelBuilder class of kernel.h
104     
105     */
106   
107    const std::string & getName() const {
108        return mKernelName;
109    }
110       
111    virtual bool isCachable() const = 0;
112
113    virtual std::string makeSignature(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
114
115    const std::vector<Binding> & getStreamInputs() const {
116        return mStreamSetInputs;
117    }
118
119    const Binding & getStreamInput(const unsigned i) const {
120        assert (i < getNumOfStreamInputs());
121        return mStreamSetInputs[i];
122    }
123
124    unsigned getNumOfStreamInputs() const {
125        return mStreamSetInputs.size();
126    }
127
128    const std::vector<Binding> & getStreamOutputs() const {
129        return mStreamSetOutputs;
130    }
131
132    unsigned getNumOfStreamOutputs() const {
133        return mStreamSetOutputs.size();
134    }
135
136    const Binding & getStreamOutput(const unsigned i) const {
137        assert (i < getNumOfStreamOutputs());
138        return mStreamSetOutputs[i];
139    }
140
141    const std::vector<Binding> & getScalarInputs() const {
142        return mScalarInputs;
143    }
144
145    const Binding & getScalarInput(const unsigned i) const {
146        return mScalarInputs[i];
147    }
148
149    const std::vector<Binding> & getScalarOutputs() const {
150        return mScalarOutputs;
151    }
152
153    const Binding & getScalarOutput(const unsigned i) const {
154        return mScalarOutputs[i];
155    }
156
157    // Add ExternalLinkage method declarations for the kernel to a given client module.
158    void addKernelDeclarations(const std::unique_ptr<kernel::KernelBuilder> & idb);
159
160    virtual void linkExternalMethods(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
161
162    virtual llvm::Value * createInstance(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
163
164    virtual void initializeInstance(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
165
166    virtual void finalizeInstance(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
167
168    void setInitialArguments(std::vector<llvm::Value *> && args) {
169        mInitialArguments.swap(args);
170    }
171
172    llvm::Value * getInstance() const {
173        return mKernelInstance;
174    }
175
176    void setInstance(llvm::Value * const instance);
177
178    bool hasPrincipalItemCount() const {
179        return mHasPrincipalItemCount;
180    }
181
182protected:
183
184    llvm::Function * getInitFunction(llvm::Module * const module) const;
185
186    llvm::Function * getDoSegmentFunction(llvm::Module * const module) const;
187
188    llvm::Function * getTerminateFunction(llvm::Module * const module) const;
189
190    llvm::CallInst * makeDoSegmentCall(KernelBuilder & idb, const std::vector<llvm::Value *> & args) const;
191
192    KernelInterface(const std::string && kernelName,
193                    Bindings && stream_inputs,
194                    Bindings && stream_outputs,
195                    Bindings && scalar_inputs,
196                    Bindings && scalar_outputs,
197                    Bindings && internal_scalars)
198    : mKernelInstance(nullptr)
199    , mModule(nullptr)
200    , mKernelStateType(nullptr)
201    , mHasPrincipalItemCount(false)
202    , mKernelName(kernelName)
203    , mStreamSetInputs(stream_inputs)
204    , mStreamSetOutputs(stream_outputs)
205    , mScalarInputs(scalar_inputs)
206    , mScalarOutputs(scalar_outputs)
207    , mInternalScalars(internal_scalars) {
208
209    }
210   
211protected:
212
213    llvm::Value *                   mKernelInstance;
214    llvm::Module *                  mModule;
215    llvm::StructType *              mKernelStateType;
216    bool                            mHasPrincipalItemCount;
217    const std::string               mKernelName;
218    std::vector<llvm::Value *>      mInitialArguments;
219    Bindings                        mStreamSetInputs;
220    Bindings                        mStreamSetOutputs;
221    Bindings                        mScalarInputs;
222    Bindings                        mScalarOutputs;
223    Bindings                        mInternalScalars;
224};
225
226}
227
228#endif
Note: See TracBrowser for help on using the repository browser.