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

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