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

Last change on this file since 5590 was 5590, checked in by xuedongx, 21 months ago

bug fix and setName for kernel for future use

File size: 8.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 <llvm/IR/Constants.h>
10#include <string>
11#include <vector>
12
13namespace IDISA { class IDISA_Builder; }
14namespace kernel { class Kernel; }
15namespace kernel { class KernelBuilder; }
16
17// Processing rate attributes are required for all stream set bindings for a kernel.
18// These attributes describe the number of items that are processed or produced as
19// a ratio in comparison to a reference stream set, normally the principal input stream set
20// by default (or the principal output stream set if there is no input).
21//
22// The default ratio is FixedRatio(1) which means that there is one item processed or
23// produced for every item of the reference stream.
24// FixedRatio(m, n) means that for every group of n items of the refrence stream,
25// there are m items in the output stream (rounding up).
26//
27// Kernels which produce a variable number of items use MaxRatio(n), for a maximum
28// of n items produced or consumed per principal input or output item.  MaxRatio(m, n)
29// means there are at most m items for every n items of the reference stream.
30//
31// RoundUpToMultiple(n) means that number of items produced is the same as the
32// number of reference items, rounded up to an exact multiple of n.
33//
34
35struct ProcessingRate  {
36    friend class kernel::Kernel;
37    enum class ProcessingRateKind : uint8_t { FixedRatio, RoundUp, Add1, MaxRatio, Unknown };
38    ProcessingRateKind getKind() const {return mKind;}
39    bool isFixedRatio() const {return mKind == ProcessingRateKind::FixedRatio;}
40    bool isMaxRatio() const {return mKind == ProcessingRateKind::MaxRatio;}
41    bool isExact() const {return (mKind == ProcessingRateKind::FixedRatio)||(mKind == ProcessingRateKind::RoundUp)||(mKind == ProcessingRateKind::Add1) ;}
42    bool isUnknownRate() const { return mKind == ProcessingRateKind::Unknown; }
43    unsigned calculateRatio(unsigned referenceItems, bool doFinal = false) const;
44    unsigned calculateMaxReferenceItems(unsigned outputItems, bool doFinal = false) const;
45    llvm::Value * CreateRatioCalculation(IDISA::IDISA_Builder * const b, llvm::Value * referenceItems, llvm::Value * doFinal = nullptr) const;
46    llvm::Value * CreateMaxReferenceItemsCalculation(IDISA::IDISA_Builder * const b, llvm::Value * outputItems, llvm::Value * doFinal = nullptr) const;
47    friend ProcessingRate FixedRatio(unsigned strmItems, unsigned referenceItems, std::string && referenceStreamSet);
48    friend ProcessingRate MaxRatio(unsigned strmItems, unsigned referenceItems, std::string && referenceStreamSet);
49    friend ProcessingRate RoundUpToMultiple(unsigned itemMultiple, std::string && referenceStreamSet);
50    friend ProcessingRate Add1(std::string && referenceStreamSet);
51    friend ProcessingRate UnknownRate();
52    uint16_t getRatioNumerator() const { return mRatioNumerator;}
53    uint16_t getRatioDenominator() const { return mRatioDenominator;}
54    const std::string & referenceStreamSet() const { return mReferenceStreamSet;}
55protected:
56    ProcessingRate(ProcessingRateKind k, unsigned numerator, unsigned denominator, std::string && referenceStreamSet)
57    : mKind(k), mRatioNumerator(numerator), mRatioDenominator(denominator), mReferenceStreamSet(referenceStreamSet) {}
58    void setReferenceStreamSet(const std::string & s) {mReferenceStreamSet = s;}
59private:
60    const ProcessingRateKind mKind;
61    const uint16_t mRatioNumerator;
62    const uint16_t mRatioDenominator;
63    std::string mReferenceStreamSet;
64}; 
65
66ProcessingRate FixedRatio(unsigned strmItems, unsigned referenceItems = 1, std::string && referenceStreamSet = "");
67ProcessingRate MaxRatio(unsigned strmItems, unsigned referenceItems = 1, std::string && referenceStreamSet = "");
68ProcessingRate RoundUpToMultiple(unsigned itemMultiple, std::string &&referenceStreamSet = "");
69ProcessingRate Add1(std::string && referenceStreamSet = "");
70ProcessingRate UnknownRate();
71
72struct Binding {
73    Binding(llvm::Type * type, const std::string & name, ProcessingRate r = FixedRatio(1))
74    : type(type), name(name), rate(r) { }
75    llvm::Type * const        type;
76    const std::string         name;
77    ProcessingRate      rate;
78};
79
80class KernelInterface {
81public:
82    /*
83     
84     This class defines the methods to be used to generate the code 
85     necessary for declaring, allocating, calling and synchronizing
86     kernels.   The methods to be used for constructing kernels are defined
87     within the KernelBuilder class of kernel.h
88     
89     */
90   
91    const std::string & getName() const {
92        return mKernelName;
93    }
94       
95    void setName(std::string newName) { mKernelName = newName; }
96
97    virtual bool isCachable() const = 0;
98
99    virtual std::string makeSignature(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
100
101    const std::vector<Binding> & getStreamInputs() const {
102        return mStreamSetInputs;
103    }
104
105    const Binding & getStreamInput(const unsigned i) const {
106        return mStreamSetInputs[i];
107    }
108
109    const std::vector<Binding> & getStreamOutputs() const {
110        return mStreamSetOutputs;
111    }
112
113    const Binding & getStreamOutput(const unsigned i) const {
114        return mStreamSetOutputs[i];
115    }
116
117    const std::vector<Binding> & getScalarInputs() const {
118        return mScalarInputs;
119    }
120
121    const Binding & getScalarInput(const unsigned i) const {
122        return mScalarInputs[i];
123    }
124
125    const std::vector<Binding> & getScalarOutputs() const {
126        return mScalarOutputs;
127    }
128
129    const Binding & getScalarOutput(const unsigned i) const {
130        return mScalarOutputs[i];
131    }
132
133    // Add ExternalLinkage method declarations for the kernel to a given client module.
134    void addKernelDeclarations(const std::unique_ptr<kernel::KernelBuilder> & idb);
135
136    virtual void linkExternalMethods(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
137
138    virtual llvm::Value * createInstance(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
139
140    virtual void initializeInstance(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
141
142    virtual void finalizeInstance(const std::unique_ptr<kernel::KernelBuilder> & idb) = 0;
143
144    void setInitialArguments(std::vector<llvm::Value *> && args) {
145        mInitialArguments.swap(args);
146    }
147
148    llvm::Value * getInstance() const {
149        return mKernelInstance;
150    }
151
152    void setInstance(llvm::Value * const instance) {
153        assert ("kernel instance cannot be null!" && instance);
154        assert ("kernel instance must point to a valid kernel state type!" && (instance->getType()->getPointerElementType() == mKernelStateType));
155        mKernelInstance = instance;
156    }
157
158    unsigned getLookAhead() const {
159        return mLookAheadPositions;
160    }
161
162    void setLookAhead(const unsigned lookAheadPositions) {
163        mLookAheadPositions = lookAheadPositions;
164    }
165
166protected:
167
168    llvm::Function * getInitFunction(llvm::Module * const module) const;
169
170    llvm::Function * getDoSegmentFunction(llvm::Module * const module) const;
171
172    llvm::Function * getTerminateFunction(llvm::Module * const module) const;
173
174    KernelInterface(std::string kernelName,
175                    std::vector<Binding> && stream_inputs,
176                    std::vector<Binding> && stream_outputs,
177                    std::vector<Binding> && scalar_inputs,
178                    std::vector<Binding> && scalar_outputs,
179                    std::vector<Binding> && internal_scalars)
180    : mKernelInstance(nullptr)
181    , mModule(nullptr)
182    , mKernelStateType(nullptr)
183    , mLookAheadPositions(0)
184    , mKernelName(kernelName)
185    , mStreamSetInputs(stream_inputs)
186    , mStreamSetOutputs(stream_outputs)
187    , mScalarInputs(scalar_inputs)
188    , mScalarOutputs(scalar_outputs)
189    , mInternalScalars(internal_scalars) {
190
191    }
192   
193protected:
194
195    llvm::Value *                           mKernelInstance;
196    llvm::Module *                          mModule;
197    llvm::StructType *                      mKernelStateType;
198    unsigned                                mLookAheadPositions;
199    std::string                             mKernelName;
200    std::vector<llvm::Value *>              mInitialArguments;
201    std::vector<Binding>                    mStreamSetInputs;
202    std::vector<Binding>                    mStreamSetOutputs;
203    std::vector<Binding>                    mScalarInputs;
204    std::vector<Binding>                    mScalarOutputs;
205    std::vector<Binding>                    mInternalScalars;
206};
207
208#endif
Note: See TracBrowser for help on using the repository browser.