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

Last change on this file since 5706 was 5706, checked in by nmedfort, 19 months ago

First stage of MultiBlockKernel? and pipeline restructuring

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