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

Last change on this file since 6133 was 5985, checked in by nmedfort, 15 months ago

Restructured MultiBlock? kernel. Removal of Swizzled buffers. Inclusion of PopCount? rates / non-linear access. Modifications to several kernels to better align them with the kernel and pipeline changes.

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