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

Last change on this file since 5782 was 5782, checked in by nmedfort, 17 months ago

Initial check-in of LookAhead? support; modified LineBreakKernel? to compute CR+LF using LookAhead?(1) + misc. fixes.

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