diff options
Diffstat (limited to 'compiler/luci/lang/include/luci')
149 files changed, 1596 insertions, 608 deletions
diff --git a/compiler/luci/lang/include/luci/IR/AttrDilation.h b/compiler/luci/lang/include/luci/IR/AttrDilation.h index c2b28d77d..ed8232576 100644 --- a/compiler/luci/lang/include/luci/IR/AttrDilation.h +++ b/compiler/luci/lang/include/luci/IR/AttrDilation.h @@ -27,15 +27,17 @@ class Dilation final public: Dilation() : _w(1), _h(1) {} - int32_t w() const { return _w; } - void w(int32_t w) { _w = w; } + uint32_t w() const { return _w; } + void w(uint32_t w) { _w = w; } + void w(int32_t w); - int32_t h() const { return _h; } - void h(int32_t h) { _h = h; } + uint32_t h() const { return _h; } + void h(uint32_t h) { _h = h; } + void h(int32_t h); private: - int32_t _w; - int32_t _h; + uint32_t _w; + uint32_t _h; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/AttrFilter.h b/compiler/luci/lang/include/luci/IR/AttrFilter.h index 7909fa523..af9d7519f 100644 --- a/compiler/luci/lang/include/luci/IR/AttrFilter.h +++ b/compiler/luci/lang/include/luci/IR/AttrFilter.h @@ -27,15 +27,17 @@ class Filter final public: Filter() : _w(1), _h(1) {} - int32_t w() const { return _w; } - void w(int32_t w) { _w = w; } + uint32_t w() const { return _w; } + void w(uint32_t w) { _w = w; } + void w(int32_t w); - int32_t h() const { return _h; } - void h(int32_t h) { _h = h; } + uint32_t h() const { return _h; } + void h(uint32_t h) { _h = h; } + void h(int32_t h); private: - int32_t _w; - int32_t _h; + uint32_t _w; + uint32_t _h; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/AttrFusedActFunc.h b/compiler/luci/lang/include/luci/IR/AttrFusedActFunc.h index 2abae604b..3f21d5858 100644 --- a/compiler/luci/lang/include/luci/IR/AttrFusedActFunc.h +++ b/compiler/luci/lang/include/luci/IR/AttrFusedActFunc.h @@ -28,7 +28,9 @@ enum class FusedActFunc NONE, RELU, RELU_N1_TO_1, - RELU6 + RELU6, + TANH, + SIGN_BIT }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/AttrStride.h b/compiler/luci/lang/include/luci/IR/AttrStride.h index 654967d73..6be697975 100644 --- a/compiler/luci/lang/include/luci/IR/AttrStride.h +++ b/compiler/luci/lang/include/luci/IR/AttrStride.h @@ -27,15 +27,17 @@ class Stride final public: Stride() : _w(1), _h(1) {} - int32_t w() const { return _w; } - void w(int32_t w) { _w = w; } + uint32_t w() const { return _w; } + void w(uint32_t w) { _w = w; } + void w(int32_t w); - int32_t h() const { return _h; } - void h(int32_t h) { _h = h; } + uint32_t h() const { return _h; } + void h(uint32_t h) { _h = h; } + void h(int32_t h); private: - int32_t _w; - int32_t _h; + uint32_t _w; + uint32_t _h; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/CircleNodeDecl.h b/compiler/luci/lang/include/luci/IR/CircleNodeDecl.h index 967103e3c..edec9d18b 100644 --- a/compiler/luci/lang/include/luci/IR/CircleNodeDecl.h +++ b/compiler/luci/lang/include/luci/IR/CircleNodeDecl.h @@ -25,6 +25,7 @@ #include "CircleOpcode.h" #include "CircleNodeVisitor.forward.h" #include "CircleQuantParam.h" +#include "SparsityParam.h" #include <memory> @@ -54,6 +55,12 @@ struct CircleNode : public loco::Node, _quantparam = std::move(quantparam); } + SparsityParam *sparsityparam(void) const { return _sparsityparam.get(); } + void sparsityparam(std::unique_ptr<SparsityParam> &&sparsityparam) + { + _sparsityparam = std::move(sparsityparam); + } + ShapeStatus shape_status(void) const { return _shape_status; } void shape_status(ShapeStatus ss) { _shape_status = ss; } @@ -63,6 +70,7 @@ struct CircleNode : public loco::Node, private: NodeName _name; std::unique_ptr<CircleQuantParam> _quantparam; + std::unique_ptr<SparsityParam> _sparsityparam; ShapeStatus _shape_status{ShapeStatus::UNDEFINED}; int32_t _op_version = 1; }; diff --git a/compiler/luci/lang/include/luci/IR/CircleNodeImpl.h b/compiler/luci/lang/include/luci/IR/CircleNodeImpl.h index a6b9488db..4b3178b9b 100644 --- a/compiler/luci/lang/include/luci/IR/CircleNodeImpl.h +++ b/compiler/luci/lang/include/luci/IR/CircleNodeImpl.h @@ -34,8 +34,10 @@ template <typename T> T CircleNode::accept(CircleNodeVisitorBase<T> *v) const \ case CircleOpcode::OPCODE: \ return v->visit(dynamic_cast<const CLASS *>(this)); +#define CIRCLE_VNODE CIRCLE_NODE #include "CircleNodes.lst" +#undef CIRCLE_VNODE #undef CIRCLE_NODE default: @@ -53,8 +55,10 @@ template <typename T> T CircleNode::accept(CircleNodeMutableVisitorBase<T> *v) \ case CircleOpcode::OPCODE: \ return v->visit(dynamic_cast<CLASS *>(this)); +#define CIRCLE_VNODE CIRCLE_NODE #include "CircleNodes.lst" +#undef CIRCLE_VNODE #undef CIRCLE_NODE default: diff --git a/compiler/luci/lang/include/luci/IR/CircleNodeMixins.h b/compiler/luci/lang/include/luci/IR/CircleNodeMixins.h new file mode 100644 index 000000000..158d65d90 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/CircleNodeMixins.h @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLE_NODE_MIXINS_H__ +#define __LUCI_IR_CIRCLE_NODE_MIXINS_H__ + +#include "luci/IR/AttrFusedActFunc.h" + +#include <loco/IR/Node.h> +#include <loco/IR/NodeMixins.h> + +#include <vector> + +namespace luci +{ + +/// @brief enumeration of mixin class +enum class CircleNodeTrait +{ + FusedActFunc, + Bias +}; + +template <CircleNodeTrait T> class CircleNodeMixin; + +template <> class CircleNodeMixin<CircleNodeTrait::FusedActFunc> +{ +public: + CircleNodeMixin() = default; + +public: + FusedActFunc fusedActivationFunction() const { return _fused_act_fun; } + void fusedActivationFunction(FusedActFunc fused_act_fun) { _fused_act_fun = fused_act_fun; } + +private: + FusedActFunc _fused_act_fun = FusedActFunc::UNDEFINED; +}; + +/** + * @brief Mixin class for nodes that has a bias input + */ +template <> class CircleNodeMixin<CircleNodeTrait::Bias> +{ +public: + CircleNodeMixin() = default; + +public: + virtual loco::Node *bias(void) const = 0; /// @brief get the input for bias. + virtual void bias(loco::Node *node) = 0; /// @brief set the input for bias. +}; + +/** + * @brief Nodes with the fixed number of inputs + * + * TODO Deprecated this class, and use loco::FixedArity instead + */ +template <uint32_t N, typename Base> class FixedArityNode : public Base +{ +public: + FixedArityNode() + { + _args.resize(N); + for (uint32_t n = 0; n < N; ++n) + { + _args[n] = std::make_unique<loco::Use>(this); + } + } + + virtual ~FixedArityNode() = default; + +public: + uint32_t arity(void) const final { return N; } + + loco::Node *arg(uint32_t n) const final { return _args.at(n)->node(); } + + void drop(void) final + { + for (uint32_t n = 0; n < N; ++n) + { + _args.at(n)->node(nullptr); + } + } + +protected: + // This API allows inherited classes to access "_args" field. + loco::Use *at(uint32_t n) const { return _args.at(n).get(); } + +private: + std::vector<std::unique_ptr<loco::Use>> _args{}; +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLE_NODE_MIXINS_H__ diff --git a/compiler/luci/lang/include/luci/IR/CircleNodeVisitor.h b/compiler/luci/lang/include/luci/IR/CircleNodeVisitor.h index 43339fe84..599e4bcd9 100644 --- a/compiler/luci/lang/include/luci/IR/CircleNodeVisitor.h +++ b/compiler/luci/lang/include/luci/IR/CircleNodeVisitor.h @@ -33,8 +33,10 @@ template <typename T> struct CircleNodeVisitorBase virtual ~CircleNodeVisitorBase() = default; #define CIRCLE_NODE(OPCODE, CIRCLE_CLASS) virtual T visit(const CIRCLE_CLASS *) = 0; +#define CIRCLE_VNODE CIRCLE_NODE #include "CircleNodes.lst" +#undef CIRCLE_VNODE #undef CIRCLE_NODE }; @@ -44,9 +46,11 @@ template <typename T> struct CircleNodeVisitor : public CircleNodeVisitorBase<T> #define CIRCLE_NODE(OPCODE, CIRCLE_CLASS) \ virtual T visit(const CIRCLE_CLASS *node) { return visit(static_cast<const CircleNode *>(node)); } +#define CIRCLE_VNODE CIRCLE_NODE #include "CircleNodes.lst" +#undef CIRCLE_VNODE #undef CIRCLE_NODE /// @brief Default fallback @@ -61,9 +65,11 @@ template <typename T> struct CircleNodeMutableVisitorBase virtual ~CircleNodeMutableVisitorBase() = default; #define CIRCLE_NODE(OPCODE, CIRCLE_CLASS) virtual T visit(CIRCLE_CLASS *) = 0; +#define CIRCLE_VNODE CIRCLE_NODE #include "CircleNodes.lst" +#undef CIRCLE_VNODE #undef CIRCLE_NODE }; @@ -73,9 +79,11 @@ template <typename T> struct CircleNodeMutableVisitor : public CircleNodeMutable #define CIRCLE_NODE(OPCODE, CIRCLE_CLASS) \ virtual T visit(CIRCLE_CLASS *node) { return visit(static_cast<CircleNode *>(node)); } +#define CIRCLE_VNODE CIRCLE_NODE #include "CircleNodes.lst" +#undef CIRCLE_VNODE #undef CIRCLE_NODE /// @brief Default fallback diff --git a/compiler/luci/lang/include/luci/IR/CircleNodes.h b/compiler/luci/lang/include/luci/IR/CircleNodes.h index 25b86d2e9..d643b0893 100644 --- a/compiler/luci/lang/include/luci/IR/CircleNodes.h +++ b/compiler/luci/lang/include/luci/IR/CircleNodes.h @@ -25,20 +25,23 @@ #include "Nodes/CircleAveragePool2D.h" #include "Nodes/CircleBatchMatMul.h" #include "Nodes/CircleBatchToSpaceND.h" +#include "Nodes/CircleBidirectionalSequenceLSTM.h" #include "Nodes/CircleCast.h" #include "Nodes/CircleCeil.h" #include "Nodes/CircleConcatenation.h" -#include "Nodes/CircleConst.h" #include "Nodes/CircleConv2D.h" #include "Nodes/CircleCos.h" #include "Nodes/CircleCustom.h" +#include "Nodes/CircleDensify.h" #include "Nodes/CircleDepthToSpace.h" #include "Nodes/CircleDepthwiseConv2D.h" +#include "Nodes/CircleDequantize.h" #include "Nodes/CircleDiv.h" #include "Nodes/CircleElu.h" #include "Nodes/CircleEqual.h" #include "Nodes/CircleExp.h" #include "Nodes/CircleExpandDims.h" +#include "Nodes/CircleFakeQuant.h" #include "Nodes/CircleFill.h" #include "Nodes/CircleFloor.h" #include "Nodes/CircleFloorDiv.h" @@ -46,8 +49,10 @@ #include "Nodes/CircleFullyConnected.h" #include "Nodes/CircleGather.h" #include "Nodes/CircleGatherNd.h" +#include "Nodes/CircleGelu.h" #include "Nodes/CircleGreater.h" #include "Nodes/CircleGreaterEqual.h" +#include "Nodes/CircleHardSwish.h" #include "Nodes/CircleIf.h" #include "Nodes/CircleL2Normalize.h" #include "Nodes/CircleL2Pool2D.h" @@ -78,6 +83,7 @@ #include "Nodes/CirclePad.h" #include "Nodes/CirclePadV2.h" #include "Nodes/CirclePow.h" +#include "Nodes/CircleQuantize.h" #include "Nodes/CirclePRelu.h" #include "Nodes/CircleRange.h" #include "Nodes/CircleRank.h" @@ -115,11 +121,13 @@ #include "Nodes/CircleStridedSlice.h" #include "Nodes/CircleSub.h" #include "Nodes/CircleSum.h" +#include "Nodes/CircleSVDF.h" #include "Nodes/CircleTanh.h" #include "Nodes/CircleTile.h" #include "Nodes/CircleTopKV2.h" #include "Nodes/CircleTranspose.h" #include "Nodes/CircleTransposeConv.h" +#include "Nodes/CircleUnidirectionalSequenceLSTM.h" #include "Nodes/CircleUnique.h" #include "Nodes/CircleUnpack.h" #include "Nodes/CircleWhere.h" @@ -130,17 +138,21 @@ #include "Nodes/CircleBCQGather.h" #include "Nodes/CircleInstanceNorm.h" // Virtual nodes +#include "Nodes/CircleConst.h" #include "Nodes/CircleInput.h" #include "Nodes/CircleOutput.h" +#include "Nodes/CircleVariable.h" +// Multi-output virtual nodes +#include "Nodes/CircleBidirectionalSequenceLSTMOut.h" #include "Nodes/CircleCustomOut.h" #include "Nodes/CircleIfOut.h" #include "Nodes/CircleNonMaxSuppressionV4Out.h" #include "Nodes/CircleNonMaxSuppressionV5Out.h" -#include "Nodes/CircleUnpackOut.h" -#include "Nodes/CircleUniqueOut.h" #include "Nodes/CircleSplitOut.h" #include "Nodes/CircleSplitVOut.h" #include "Nodes/CircleTopKV2Out.h" +#include "Nodes/CircleUniqueOut.h" +#include "Nodes/CircleUnpackOut.h" #include "Nodes/CircleWhileOut.h" #include <loco/IR/Graph.h> @@ -148,15 +160,6 @@ namespace luci { -/** - * @brief Set both CircleReshape's 2nd input as CircleConst, and newShape attribute - * with same value - * @note Shape inference for TFLReshape forces them to be same - * - * TODO find better place for this helper - */ -void set_new_shape(CircleReshape *node, int32_t *base, uint32_t size); - /// @brief Link GraphOutput with CircleOutput node void link(loco::GraphOutput *, CircleOutput *); diff --git a/compiler/luci/lang/include/luci/IR/CircleNodes.lst b/compiler/luci/lang/include/luci/IR/CircleNodes.lst index 9f0a1b16e..1646909e8 100644 --- a/compiler/luci/lang/include/luci/IR/CircleNodes.lst +++ b/compiler/luci/lang/include/luci/IR/CircleNodes.lst @@ -2,6 +2,10 @@ #error "Define CIRCLE_NODE" #endif // CIRCLE_NODE +#ifndef CIRCLE_VNODE +#error "Define CIRCLE_VNODE" +#endif // CIRCLE_VNODE + // // PLEASE SORT NODE DECLS IN ALPHABETICAL ORDER // @@ -11,130 +15,142 @@ // .Input("value: T") <-- Input name is 'value' // -CIRCLE_NODE(ABS, luci::CircleAbs) -CIRCLE_NODE(ADD, luci::CircleAdd) -CIRCLE_NODE(ADD_N, luci::CircleAddN) -CIRCLE_NODE(ARG_MAX, luci::CircleArgMax) -CIRCLE_NODE(ARG_MIN, luci::CircleArgMin) -CIRCLE_NODE(AVERAGE_POOL_2D, luci::CircleAveragePool2D) -CIRCLE_NODE(BATCH_TO_SPACE_ND, luci::CircleBatchToSpaceND) -CIRCLE_NODE(BATCHMATMUL, luci::CircleBatchMatMul) -CIRCLE_NODE(CAST, luci::CircleCast) -CIRCLE_NODE(CEIL, luci::CircleCeil) -CIRCLE_NODE(CONCATENATION, luci::CircleConcatenation) -CIRCLE_NODE(CONV_2D, luci::CircleConv2D) -CIRCLE_NODE(COS, luci::CircleCos) -CIRCLE_NODE(CUSTOM, luci::CircleCustom) -CIRCLE_NODE(DEPTH_TO_SPACE, luci::CircleDepthToSpace) -CIRCLE_NODE(DEPTHWISE_CONV_2D, luci::CircleDepthwiseConv2D) -CIRCLE_NODE(DIV, luci::CircleDiv) -CIRCLE_NODE(ELU, luci::CircleElu) -CIRCLE_NODE(EQUAL, luci::CircleEqual) -CIRCLE_NODE(EXP, luci::CircleExp) -CIRCLE_NODE(EXPAND_DIMS, luci::CircleExpandDims) -CIRCLE_NODE(FILL, luci::CircleFill) -CIRCLE_NODE(FLOOR, luci::CircleFloor) -CIRCLE_NODE(FLOOR_DIV, luci::CircleFloorDiv) -CIRCLE_NODE(FLOOR_MOD, luci::CircleFloorMod) -CIRCLE_NODE(FULLY_CONNECTED, luci::CircleFullyConnected) -CIRCLE_NODE(GATHER, luci::CircleGather) -CIRCLE_NODE(GATHER_ND, luci::CircleGatherNd) -CIRCLE_NODE(GREATER, luci::CircleGreater) -CIRCLE_NODE(GREATER_EQUAL, luci::CircleGreaterEqual) -CIRCLE_NODE(IF, luci::CircleIf) -CIRCLE_NODE(L2_NORMALIZATION, luci::CircleL2Normalize) -CIRCLE_NODE(L2_POOL_2D, luci::CircleL2Pool2D) -CIRCLE_NODE(LEAKY_RELU, luci::CircleLeakyRelu) -CIRCLE_NODE(LESS, luci::CircleLess) -CIRCLE_NODE(LESS_EQUAL, luci::CircleLessEqual) -CIRCLE_NODE(LOCAL_RESPONSE_NORMALIZATION, luci::CircleLocalResponseNormalization) -CIRCLE_NODE(LOG, luci::CircleLog) -CIRCLE_NODE(LOGICAL_AND, luci::CircleLogicalAnd) -CIRCLE_NODE(LOGICAL_NOT, luci::CircleLogicalNot) -CIRCLE_NODE(LOGICAL_OR, luci::CircleLogicalOr) -CIRCLE_NODE(LOGISTIC, luci::CircleLogistic) -CIRCLE_NODE(LOG_SOFTMAX, luci::CircleLogSoftmax) -CIRCLE_NODE(MATRIX_DIAG, luci::CircleMatrixDiag) -CIRCLE_NODE(MAX_POOL_2D, luci::CircleMaxPool2D) -CIRCLE_NODE(MATRIX_SET_DIAG, luci::CircleMatrixSetDiag) -CIRCLE_NODE(MAXIMUM, luci::CircleMaximum) -CIRCLE_NODE(MEAN, luci::CircleMean) -CIRCLE_NODE(MINIMUM, luci::CircleMinimum) -CIRCLE_NODE(MIRROR_PAD, luci::CircleMirrorPad) -CIRCLE_NODE(MUL, luci::CircleMul) -CIRCLE_NODE(NEG, luci::CircleNeg) -CIRCLE_NODE(NON_MAX_SUPPRESSION_V4, luci::CircleNonMaxSuppressionV4) -CIRCLE_NODE(NON_MAX_SUPPRESSION_V5, luci::CircleNonMaxSuppressionV5) -CIRCLE_NODE(NOT_EQUAL, luci::CircleNotEqual) -CIRCLE_NODE(ONE_HOT, luci::CircleOneHot) -CIRCLE_NODE(PACK, luci::CirclePack) -CIRCLE_NODE(PAD, luci::CirclePad) -CIRCLE_NODE(PADV2, luci::CirclePadV2) -CIRCLE_NODE(POW, luci::CirclePow) -CIRCLE_NODE(PRELU, luci::CirclePRelu) -CIRCLE_NODE(RANGE, luci::CircleRange) -CIRCLE_NODE(RANK, luci::CircleRank) -CIRCLE_NODE(REDUCE_ANY, luci::CircleReduceAny) -CIRCLE_NODE(REDUCE_MAX, luci::CircleReduceMax) -CIRCLE_NODE(REDUCE_MIN, luci::CircleReduceMin) -CIRCLE_NODE(REDUCE_PROD, luci::CircleReduceProd) -CIRCLE_NODE(RELU, luci::CircleRelu) -CIRCLE_NODE(RELU6, luci::CircleRelu6) -CIRCLE_NODE(RELU_N1_TO_1, luci::CircleReluN1To1) -CIRCLE_NODE(RESHAPE, luci::CircleReshape) -CIRCLE_NODE(RESIZE_BILINEAR, luci::CircleResizeBilinear) -CIRCLE_NODE(RESIZE_NEAREST_NEIGHBOR, luci::CircleResizeNearestNeighbor) -CIRCLE_NODE(REVERSE_SEQUENCE, luci::CircleReverseSequence) -CIRCLE_NODE(REVERSE_V2, luci::CircleReverseV2) -CIRCLE_NODE(ROUND, luci::CircleRound) -CIRCLE_NODE(RSQRT, luci::CircleRsqrt) -CIRCLE_NODE(SCATTER_ND, luci::CircleScatterNd) -CIRCLE_NODE(SEGMENT_SUM, luci::CircleSegmentSum) -CIRCLE_NODE(SELECT, luci::CircleSelect) -CIRCLE_NODE(SELECT_V2, luci::CircleSelectV2) -CIRCLE_NODE(SHAPE, luci::CircleShape) -CIRCLE_NODE(SIN, luci::CircleSin) -CIRCLE_NODE(SLICE, luci::CircleSlice) -CIRCLE_NODE(SOFTMAX, luci::CircleSoftmax) -CIRCLE_NODE(SPACE_TO_BATCH_ND, luci::CircleSpaceToBatchND) -CIRCLE_NODE(SPACE_TO_DEPTH, luci::CircleSpaceToDepth) -CIRCLE_NODE(SPARSE_TO_DENSE, luci::CircleSparseToDense) -CIRCLE_NODE(SPLIT, luci::CircleSplit) -CIRCLE_NODE(SPLIT_V, luci::CircleSplitV) -CIRCLE_NODE(SQRT, luci::CircleSqrt) -CIRCLE_NODE(SQUARE, luci::CircleSquare) -CIRCLE_NODE(SQUARED_DIFFERENCE, luci::CircleSquaredDifference) -CIRCLE_NODE(SQUEEZE, luci::CircleSqueeze) -CIRCLE_NODE(STRIDED_SLICE, luci::CircleStridedSlice) -CIRCLE_NODE(SUB, luci::CircleSub) -CIRCLE_NODE(SUM, luci::CircleSum) -CIRCLE_NODE(TANH, luci::CircleTanh) -CIRCLE_NODE(TILE, luci::CircleTile) -CIRCLE_NODE(TOPK_V2, luci::CircleTopKV2) -CIRCLE_NODE(TRANSPOSE, luci::CircleTranspose) -CIRCLE_NODE(TRANSPOSE_CONV, luci::CircleTransposeConv) -CIRCLE_NODE(UNIQUE, luci::CircleUnique) -CIRCLE_NODE(UNPACK, luci::CircleUnpack) -CIRCLE_NODE(WHERE, luci::CircleWhere) -CIRCLE_NODE(WHILE, luci::CircleWhile) -CIRCLE_NODE(ZEROS_LIKE, luci::CircleZerosLike) +CIRCLE_NODE(ABS, CircleAbs) +CIRCLE_NODE(ADD, CircleAdd) +CIRCLE_NODE(ADD_N, CircleAddN) +CIRCLE_NODE(ARG_MAX, CircleArgMax) +CIRCLE_NODE(ARG_MIN, CircleArgMin) +CIRCLE_NODE(AVERAGE_POOL_2D, CircleAveragePool2D) +CIRCLE_NODE(BATCH_TO_SPACE_ND, CircleBatchToSpaceND) +CIRCLE_NODE(BATCH_MATMUL, CircleBatchMatMul) +CIRCLE_NODE(BIDIRECTIONAL_SEQUENCE_LSTM, CircleBidirectionalSequenceLSTM) +CIRCLE_NODE(CAST, CircleCast) +CIRCLE_NODE(CEIL, CircleCeil) +CIRCLE_NODE(CONCATENATION, CircleConcatenation) +CIRCLE_NODE(CONV_2D, CircleConv2D) +CIRCLE_NODE(COS, CircleCos) +CIRCLE_NODE(CUSTOM, CircleCustom) +CIRCLE_NODE(DENSIFY, CircleDensify) +CIRCLE_NODE(DEPTH_TO_SPACE, CircleDepthToSpace) +CIRCLE_NODE(DEPTHWISE_CONV_2D, CircleDepthwiseConv2D) +CIRCLE_NODE(DEQUANTIZE, CircleDequantize) +CIRCLE_NODE(DIV, CircleDiv) +CIRCLE_NODE(ELU, CircleElu) +CIRCLE_NODE(EQUAL, CircleEqual) +CIRCLE_NODE(EXP, CircleExp) +CIRCLE_NODE(EXPAND_DIMS, CircleExpandDims) +CIRCLE_NODE(FAKE_QUANT, CircleFakeQuant) +CIRCLE_NODE(FILL, CircleFill) +CIRCLE_NODE(FLOOR, CircleFloor) +CIRCLE_NODE(FLOOR_DIV, CircleFloorDiv) +CIRCLE_NODE(FLOOR_MOD, CircleFloorMod) +CIRCLE_NODE(FULLY_CONNECTED, CircleFullyConnected) +CIRCLE_NODE(GATHER, CircleGather) +CIRCLE_NODE(GATHER_ND, CircleGatherNd) +CIRCLE_NODE(GELU, CircleGelu) +CIRCLE_NODE(GREATER, CircleGreater) +CIRCLE_NODE(GREATER_EQUAL, CircleGreaterEqual) +CIRCLE_NODE(HARD_SWISH, CircleHardSwish) +CIRCLE_NODE(IF, CircleIf) +CIRCLE_NODE(L2_NORMALIZATION, CircleL2Normalize) +CIRCLE_NODE(L2_POOL_2D, CircleL2Pool2D) +CIRCLE_NODE(LEAKY_RELU, CircleLeakyRelu) +CIRCLE_NODE(LESS, CircleLess) +CIRCLE_NODE(LESS_EQUAL, CircleLessEqual) +CIRCLE_NODE(LOCAL_RESPONSE_NORMALIZATION, CircleLocalResponseNormalization) +CIRCLE_NODE(LOG, CircleLog) +CIRCLE_NODE(LOGICAL_AND, CircleLogicalAnd) +CIRCLE_NODE(LOGICAL_NOT, CircleLogicalNot) +CIRCLE_NODE(LOGICAL_OR, CircleLogicalOr) +CIRCLE_NODE(LOGISTIC, CircleLogistic) +CIRCLE_NODE(LOG_SOFTMAX, CircleLogSoftmax) +CIRCLE_NODE(MATRIX_DIAG, CircleMatrixDiag) +CIRCLE_NODE(MAX_POOL_2D, CircleMaxPool2D) +CIRCLE_NODE(MATRIX_SET_DIAG, CircleMatrixSetDiag) +CIRCLE_NODE(MAXIMUM, CircleMaximum) +CIRCLE_NODE(MEAN, CircleMean) +CIRCLE_NODE(MINIMUM, CircleMinimum) +CIRCLE_NODE(MIRROR_PAD, CircleMirrorPad) +CIRCLE_NODE(MUL, CircleMul) +CIRCLE_NODE(NEG, CircleNeg) +CIRCLE_NODE(NON_MAX_SUPPRESSION_V4, CircleNonMaxSuppressionV4) +CIRCLE_NODE(NON_MAX_SUPPRESSION_V5, CircleNonMaxSuppressionV5) +CIRCLE_NODE(NOT_EQUAL, CircleNotEqual) +CIRCLE_NODE(ONE_HOT, CircleOneHot) +CIRCLE_NODE(PACK, CirclePack) +CIRCLE_NODE(PAD, CirclePad) +CIRCLE_NODE(PADV2, CirclePadV2) +CIRCLE_NODE(POW, CirclePow) +CIRCLE_NODE(PRELU, CirclePRelu) +CIRCLE_NODE(QUANTIZE, CircleQuantize) +CIRCLE_NODE(RANGE, CircleRange) +CIRCLE_NODE(RANK, CircleRank) +CIRCLE_NODE(REDUCE_ANY, CircleReduceAny) +CIRCLE_NODE(REDUCE_MAX, CircleReduceMax) +CIRCLE_NODE(REDUCE_MIN, CircleReduceMin) +CIRCLE_NODE(REDUCE_PROD, CircleReduceProd) +CIRCLE_NODE(RELU, CircleRelu) +CIRCLE_NODE(RELU6, CircleRelu6) +CIRCLE_NODE(RELU_N1_TO_1, CircleReluN1To1) +CIRCLE_NODE(RESHAPE, CircleReshape) +CIRCLE_NODE(RESIZE_BILINEAR, CircleResizeBilinear) +CIRCLE_NODE(RESIZE_NEAREST_NEIGHBOR, CircleResizeNearestNeighbor) +CIRCLE_NODE(REVERSE_SEQUENCE, CircleReverseSequence) +CIRCLE_NODE(REVERSE_V2, CircleReverseV2) +CIRCLE_NODE(ROUND, CircleRound) +CIRCLE_NODE(RSQRT, CircleRsqrt) +CIRCLE_NODE(SCATTER_ND, CircleScatterNd) +CIRCLE_NODE(SEGMENT_SUM, CircleSegmentSum) +CIRCLE_NODE(SELECT, CircleSelect) +CIRCLE_NODE(SELECT_V2, CircleSelectV2) +CIRCLE_NODE(SHAPE, CircleShape) +CIRCLE_NODE(SIN, CircleSin) +CIRCLE_NODE(SLICE, CircleSlice) +CIRCLE_NODE(SOFTMAX, CircleSoftmax) +CIRCLE_NODE(SPACE_TO_BATCH_ND, CircleSpaceToBatchND) +CIRCLE_NODE(SPACE_TO_DEPTH, CircleSpaceToDepth) +CIRCLE_NODE(SPARSE_TO_DENSE, CircleSparseToDense) +CIRCLE_NODE(SPLIT, CircleSplit) +CIRCLE_NODE(SPLIT_V, CircleSplitV) +CIRCLE_NODE(SQRT, CircleSqrt) +CIRCLE_NODE(SQUARE, CircleSquare) +CIRCLE_NODE(SQUARED_DIFFERENCE, CircleSquaredDifference) +CIRCLE_NODE(SQUEEZE, CircleSqueeze) +CIRCLE_NODE(STRIDED_SLICE, CircleStridedSlice) +CIRCLE_NODE(SUB, CircleSub) +CIRCLE_NODE(SUM, CircleSum) +CIRCLE_NODE(SVDF, CircleSVDF) +CIRCLE_NODE(TANH, CircleTanh) +CIRCLE_NODE(TILE, CircleTile) +CIRCLE_NODE(TOPK_V2, CircleTopKV2) +CIRCLE_NODE(TRANSPOSE, CircleTranspose) +CIRCLE_NODE(TRANSPOSE_CONV, CircleTransposeConv) +CIRCLE_NODE(UNIDIRECTIONAL_SEQUENCE_LSTM, CircleUnidirectionalSequenceLSTM) +CIRCLE_NODE(UNIQUE, CircleUnique) +CIRCLE_NODE(UNPACK, CircleUnpack) +CIRCLE_NODE(WHERE, CircleWhere) +CIRCLE_NODE(WHILE, CircleWhile) +CIRCLE_NODE(ZEROS_LIKE, CircleZerosLike) // Circle Only -CIRCLE_NODE(BCQ_FULLY_CONNECTED, luci::CircleBCQFullyConnected) -CIRCLE_NODE(BCQ_GATHER, luci::CircleBCQGather) -CIRCLE_NODE(INSTANCE_NORM, luci::CircleInstanceNorm) +CIRCLE_NODE(BCQ_FULLY_CONNECTED, CircleBCQFullyConnected) +CIRCLE_NODE(BCQ_GATHER, CircleBCQGather) +CIRCLE_NODE(INSTANCE_NORM, CircleInstanceNorm) // Virtual node(s) -CIRCLE_NODE(CIRCLECONST, luci::CircleConst) -CIRCLE_NODE(CIRCLEINPUT, luci::CircleInput) -CIRCLE_NODE(CIRCLEOUTPUT, luci::CircleOutput) -CIRCLE_NODE(CIRCLEOUTPUTDUMMY, luci::CircleOutputDummy) -CIRCLE_NODE(CIRCLEOUTPUTEXCLUDE, luci::CircleOutputExclude) -CIRCLE_NODE(CIRCLECUSTOMOUT, luci::CircleCustomOut) -CIRCLE_NODE(CIRCLEIFOUT, luci::CircleIfOut) -CIRCLE_NODE(CIRCLENONMAXSUPPRESSIONV4OUT, luci::CircleNonMaxSuppressionV4Out) -CIRCLE_NODE(CIRCLENONMAXSUPPRESSIONV5OUT, luci::CircleNonMaxSuppressionV5Out) -CIRCLE_NODE(CIRCLESPLITOUT, luci::CircleSplitOut) -CIRCLE_NODE(CIRCLESPLITVOUT, luci::CircleSplitVOut) -CIRCLE_NODE(CIRCLETOPKV2OUT, luci::CircleTopKV2Out) -CIRCLE_NODE(CIRCLEUNIQUEOUT, luci::CircleUniqueOut) -CIRCLE_NODE(CIRCLEUNPACKOUT, luci::CircleUnpackOut) -CIRCLE_NODE(CIRCLEWHILEOUT, luci::CircleWhileOut) +CIRCLE_VNODE(CIRCLECONST, CircleConst) +CIRCLE_VNODE(CIRCLEINPUT, CircleInput) +CIRCLE_VNODE(CIRCLEOUTPUT, CircleOutput) +CIRCLE_VNODE(CIRCLEOUTPUTDUMMY, CircleOutputDummy) +CIRCLE_VNODE(CIRCLEOUTPUTEXCLUDE, CircleOutputExclude) +CIRCLE_VNODE(CIRCLEVARIABLE, CircleVariable) +// Multi-output virtual nodes +CIRCLE_VNODE(CIRCLEBIDIRECTIONAL_SEQUENCE_LSTM_OUT, CircleBidirectionalSequenceLSTMOut) +CIRCLE_VNODE(CIRCLECUSTOMOUT, CircleCustomOut) +CIRCLE_VNODE(CIRCLEIFOUT, CircleIfOut) +CIRCLE_VNODE(CIRCLENONMAXSUPPRESSIONV4OUT, CircleNonMaxSuppressionV4Out) +CIRCLE_VNODE(CIRCLENONMAXSUPPRESSIONV5OUT, CircleNonMaxSuppressionV5Out) +CIRCLE_VNODE(CIRCLESPLITOUT, CircleSplitOut) +CIRCLE_VNODE(CIRCLESPLITVOUT, CircleSplitVOut) +CIRCLE_VNODE(CIRCLETOPKV2OUT, CircleTopKV2Out) +CIRCLE_VNODE(CIRCLEUNIQUEOUT, CircleUniqueOut) +CIRCLE_VNODE(CIRCLEUNPACKOUT, CircleUnpackOut) +CIRCLE_VNODE(CIRCLEWHILEOUT, CircleWhileOut) diff --git a/compiler/luci/lang/include/luci/IR/CircleOpcode.h b/compiler/luci/lang/include/luci/IR/CircleOpcode.h index 703b70da2..be3069f94 100644 --- a/compiler/luci/lang/include/luci/IR/CircleOpcode.h +++ b/compiler/luci/lang/include/luci/IR/CircleOpcode.h @@ -23,7 +23,9 @@ namespace luci enum class CircleOpcode { #define CIRCLE_NODE(OPCODE, CLASS) OPCODE, +#define CIRCLE_VNODE CIRCLE_NODE #include "CircleNodes.lst" +#undef CIRCLE_VNODE #undef CIRCLE_NODE }; diff --git a/compiler/luci/lang/include/luci/IR/CircleQuantParam.h b/compiler/luci/lang/include/luci/IR/CircleQuantParam.h index 694437303..8afc80a76 100644 --- a/compiler/luci/lang/include/luci/IR/CircleQuantParam.h +++ b/compiler/luci/lang/include/luci/IR/CircleQuantParam.h @@ -32,6 +32,10 @@ struct CircleQuantParam int32_t quantized_dimension{0}; }; +struct CircleNode; + +void copy_quantparam(const luci::CircleNode *src, luci::CircleNode *dst); + } // namespace luci #endif // __LUCI_IR_CIRCLEQUANTPARAM_H__ diff --git a/compiler/luci/lang/include/luci/IR/DeadNodeQueryService.h b/compiler/luci/lang/include/luci/IR/DeadNodeQueryService.h new file mode 100644 index 000000000..d10696667 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/DeadNodeQueryService.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_LANG_DEADNODEQUERYSERVICE_H__ +#define __LUCI_LANG_DEADNODEQUERYSERVICE_H__ + +#include <logo/DeadNodeQueryService.h> + +#include <loco/IR/Node.h> + +namespace luci +{ + +struct DeadNodeQueryServiceImpl final : public logo::DeadNodeQueryService +{ + bool isDeadNode(loco::Node *node) final; +}; + +} // namespace luci + +#endif // __LUCI_LANG_DEADNODEQUERYSERVICE_H__ diff --git a/compiler/luci/lang/include/luci/IR/ExecutionPlanTable.h b/compiler/luci/lang/include/luci/IR/ExecutionPlanTable.h new file mode 100644 index 000000000..5c33c1123 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/ExecutionPlanTable.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_EXECUTION_PLAN_TABLE_H__ +#define __LUCI_EXECUTION_PLAN_TABLE_H__ + +namespace luci +{ + +using ExecutionPlanTable = std::map<uint32_t, std::vector<uint32_t>>; + +} // namespace luci + +#endif // __LUCI_EXECUTION_PLAN_TABLE_H__ diff --git a/compiler/luci/lang/include/luci/IR/LuciNodeMixins.h b/compiler/luci/lang/include/luci/IR/LuciNodeMixins.h index c1bb0db11..2078495c6 100644 --- a/compiler/luci/lang/include/luci/IR/LuciNodeMixins.h +++ b/compiler/luci/lang/include/luci/IR/LuciNodeMixins.h @@ -17,90 +17,16 @@ #ifndef __LUCI_IR_LUCINODEMIXINS_H__ #define __LUCI_IR_LUCINODEMIXINS_H__ -#include "luci/IR/AttrFusedActFunc.h" +// TODO remove this file after LuciNodeTrait and LuciNodeMixin are not used in backend -#include <loco/IR/Node.h> -#include <loco/IR/NodeMixins.h> - -#include <vector> +#include "luci/IR/CircleNodeMixins.h" namespace luci { -/// @brief enumeration of mixin class -enum class LuciNodeTrait -{ - FusedActFunc, - Bias -}; - -template <LuciNodeTrait T> class LuciNodeMixin; - -template <> class LuciNodeMixin<LuciNodeTrait::FusedActFunc> -{ -public: - LuciNodeMixin() = default; - -public: - FusedActFunc fusedActivationFunction() const { return _fused_act_fun; } - void fusedActivationFunction(FusedActFunc fused_act_fun) { _fused_act_fun = fused_act_fun; } - -private: - FusedActFunc _fused_act_fun = FusedActFunc::UNDEFINED; -}; - -/** - * @brief Mixin class for nodes that has a bias input - */ -template <> class LuciNodeMixin<LuciNodeTrait::Bias> -{ -public: - LuciNodeMixin() = default; - -public: - virtual loco::Node *bias(void) const = 0; /// @brief get the input for bias. - virtual void bias(loco::Node *node) = 0; /// @brief set the input for bias. -}; - -/** - * @brief Nodes with the fixed number of inputs - * - * TODO Deprecated this class, and use loco::FixedArity instead - */ -template <unsigned N, typename Base> class FixedArityNode : public Base -{ -public: - FixedArityNode() - { - _args.resize(N); - for (uint32_t n = 0; n < N; ++n) - { - _args[n] = std::make_unique<loco::Use>(this); - } - } - - virtual ~FixedArityNode() = default; - -public: - unsigned arity(void) const final { return N; } - - loco::Node *arg(uint32_t n) const final { return _args.at(n)->node(); } - - void drop(void) final - { - for (uint32_t n = 0; n < N; ++n) - { - _args.at(n)->node(nullptr); - } - } - -protected: - // This API allows inherited classes to access "_args" field. - loco::Use *at(unsigned n) const { return _args.at(n).get(); } +using LuciNodeTrait = CircleNodeTrait; -private: - std::vector<std::unique_ptr<loco::Use>> _args{}; -}; +template <LuciNodeTrait T> using LuciNodeMixin = CircleNodeMixin<T>; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Module.h b/compiler/luci/lang/include/luci/IR/Module.h index 30eac59ce..75cf67905 100644 --- a/compiler/luci/lang/include/luci/IR/Module.h +++ b/compiler/luci/lang/include/luci/IR/Module.h @@ -19,6 +19,7 @@ #include <loco/IR/Graph.h> +#include <map> #include <memory> #include <vector> @@ -59,8 +60,27 @@ public: // TODO provide graph accessor with a name +public: + void source_table(const std::map<uint32_t, std::string> &table) { _source_table = table; } + + const std::map<uint32_t, std::string> &source_table(void) const { return _source_table; } + private: std::vector<std::unique_ptr<loco::Graph>> _graphs; + +private: + /** + * @brief Metadata about source table for profiling + * + * @note Key is ID of node and value is name of node. + * + * If there was originally imported 'source_table' in circle model, + * the table will be stored as it is. + * Otherwise, new 'source_table' is created with imported nodes. + * + * Even if Module has multiple subgraphs, only first subgraph is considered. + */ + std::map<uint32_t, std::string> _source_table; }; std::unique_ptr<Module> make_module(void); diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleAbs.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleAbs.h index 45dba15bf..7a73f37cd 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleAbs.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleAbs.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleAdd.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleAdd.h index f26eccd1a..92563de4c 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleAdd.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleAdd.h @@ -21,7 +21,7 @@ #include "luci/IR/CircleOpcode.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -30,7 +30,7 @@ namespace luci * @brief ADD in Circle */ class CircleAdd final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::ADD>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: loco::Node *x(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleArgMax.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleArgMax.h index dbc4b2b3a..c1e4631e4 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleArgMax.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleArgMax.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleArgMin.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleArgMin.h index 8cb561983..b4d026201 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleArgMin.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleArgMin.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleAveragePool2D.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleAveragePool2D.h index 0b43b40c8..4aa45c2d8 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleAveragePool2D.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleAveragePool2D.h @@ -24,7 +24,7 @@ #include "luci/IR/AttrPadding.h" #include "luci/IR/AttrStride.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -33,16 +33,14 @@ namespace luci * @brief AVERAGE_POOL_2D in Circle */ class CircleAveragePool2D final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::AVERAGE_POOL_2D>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::AVERAGE_POOL_2D>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: - CircleAveragePool2D() : _padding(Padding::UNDEFINED) { /* empty */} - -public: loco::Node *value(void) const { return at(0)->node(); } void value(loco::Node *node) { at(0)->node(node); } +public: Padding padding() const { return _padding; } void padding(Padding padding) { _padding = padding; } @@ -53,7 +51,7 @@ public: Stride *stride(void) { return &_stride; } private: - Padding _padding; + Padding _padding{Padding::UNDEFINED}; Stride _stride; Filter _filter; }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleBCQFullyConnected.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleBCQFullyConnected.h index 7d12d593a..4c164ebca 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleBCQFullyConnected.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleBCQFullyConnected.h @@ -21,7 +21,7 @@ #include "luci/IR/CircleOpcode.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -30,9 +30,9 @@ namespace luci * @brief BCQ_FULLY_CONNECTED in Circle */ class CircleBCQFullyConnected final - : public FixedArityNode<5, CircleNodeImpl<CircleOpcode::BCQ_FULLY_CONNECTED>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc>, - public LuciNodeMixin<LuciNodeTrait::Bias> + : public FixedArityNode<5, CircleNodeImpl<CircleOpcode::BCQ_FULLY_CONNECTED>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc>, + public CircleNodeMixin<CircleNodeTrait::Bias> { public: loco::Node *input(void) const { return at(0)->node(); } @@ -58,7 +58,7 @@ public: } private: - int32_t _weights_hidden_size = 0; + int32_t _weights_hidden_size{0}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleBCQGather.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleBCQGather.h index f7638261d..1a0bf4f19 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleBCQGather.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleBCQGather.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -51,8 +51,8 @@ public: void input_hidden_size(int32_t input_hidden_size) { _input_hidden_size = input_hidden_size; } private: - int32_t _axis = 0; - int32_t _input_hidden_size = 0; + int32_t _axis{0}; + int32_t _input_hidden_size{0}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleBatchMatMul.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleBatchMatMul.h index 19999924e..864b033ed 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleBatchMatMul.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleBatchMatMul.h @@ -20,15 +20,15 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { /** - * @brief BATCHMATMUL in Circle + * @brief BATCH_MATMUL in Circle */ -class CircleBatchMatMul final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::BATCHMATMUL>> +class CircleBatchMatMul final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::BATCH_MATMUL>> { public: loco::Node *x(void) const { return at(0)->node(); } @@ -45,8 +45,8 @@ public: void adj_y(bool arg) { _adj_y = arg; } private: - bool _adj_x = false; - bool _adj_y = false; + bool _adj_x{false}; + bool _adj_y{false}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleBatchToSpaceND.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleBatchToSpaceND.h index 67c0a2102..80fa53b8e 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleBatchToSpaceND.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleBatchToSpaceND.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,7 +29,7 @@ namespace luci * @brief BATCH_TO_SPACE_ND in Circle */ class CircleBatchToSpaceND final - : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::BATCH_TO_SPACE_ND>> + : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::BATCH_TO_SPACE_ND>> { public: loco::Node *input(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleBidirectionalSequenceLSTM.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleBidirectionalSequenceLSTM.h new file mode 100644 index 000000000..d16281b69 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleBidirectionalSequenceLSTM.h @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLEBIDIRECTIONALSEQUENCE_LSTM_H__ +#define __LUCI_IR_CIRCLEBIDIRECTIONALSEQUENCE_LSTM_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/AttrFusedActFunc.h" +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief BIDIRECTIONAL_SEQUENCE_LSTM in Circle + */ +class CircleBidirectionalSequenceLSTM final + : public FixedArityNode<48, CircleNodeImpl<CircleOpcode::BIDIRECTIONAL_SEQUENCE_LSTM>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> +{ +public: + loco::Node *input(void) const { return at(0)->node(); } + void input(loco::Node *node) { at(0)->node(node); } + + loco::Node *fw_input_to_input_weights(void) const { return at(1)->node(); } + void fw_input_to_input_weights(loco::Node *node) { at(1)->node(node); } + loco::Node *fw_input_to_forget_weights(void) const { return at(2)->node(); } + void fw_input_to_forget_weights(loco::Node *node) { at(2)->node(node); } + loco::Node *fw_input_to_cell_weights(void) const { return at(3)->node(); } + void fw_input_to_cell_weights(loco::Node *node) { at(3)->node(node); } + loco::Node *fw_input_to_output_weights(void) const { return at(4)->node(); } + void fw_input_to_output_weights(loco::Node *node) { at(4)->node(node); } + + loco::Node *fw_recurrent_to_input_weights(void) const { return at(5)->node(); } + void fw_recurrent_to_input_weights(loco::Node *node) { at(5)->node(node); } + loco::Node *fw_recurrent_to_forget_weights(void) const { return at(6)->node(); } + void fw_recurrent_to_forget_weights(loco::Node *node) { at(6)->node(node); } + loco::Node *fw_recurrent_to_cell_weights(void) const { return at(7)->node(); } + void fw_recurrent_to_cell_weights(loco::Node *node) { at(7)->node(node); } + loco::Node *fw_recurrent_to_output_weights(void) const { return at(8)->node(); } + void fw_recurrent_to_output_weights(loco::Node *node) { at(8)->node(node); } + + loco::Node *fw_cell_to_input_weights(void) const { return at(9)->node(); } + void fw_cell_to_input_weights(loco::Node *node) { at(9)->node(node); } + loco::Node *fw_cell_to_forget_weights(void) const { return at(10)->node(); } + void fw_cell_to_forget_weights(loco::Node *node) { at(10)->node(node); } + loco::Node *fw_cell_to_output_weights(void) const { return at(11)->node(); } + void fw_cell_to_output_weights(loco::Node *node) { at(11)->node(node); } + + loco::Node *fw_input_gate_bias(void) const { return at(12)->node(); } + void fw_input_gate_bias(loco::Node *node) { at(12)->node(node); } + loco::Node *fw_forget_gate_bias(void) const { return at(13)->node(); } + void fw_forget_gate_bias(loco::Node *node) { at(13)->node(node); } + loco::Node *fw_cell_gate_bias(void) const { return at(14)->node(); } + void fw_cell_gate_bias(loco::Node *node) { at(14)->node(node); } + loco::Node *fw_output_gate_bias(void) const { return at(15)->node(); } + void fw_output_gate_bias(loco::Node *node) { at(15)->node(node); } + + loco::Node *fw_projection_weights(void) const { return at(16)->node(); } + void fw_projection_weights(loco::Node *node) { at(16)->node(node); } + loco::Node *fw_projection_bias(void) const { return at(17)->node(); } + void fw_projection_bias(loco::Node *node) { at(17)->node(node); } + + loco::Node *bw_input_to_input_weights(void) const { return at(18)->node(); } + void bw_input_to_input_weights(loco::Node *node) { at(18)->node(node); } + loco::Node *bw_input_to_forget_weights(void) const { return at(19)->node(); } + void bw_input_to_forget_weights(loco::Node *node) { at(19)->node(node); } + loco::Node *bw_input_to_cell_weights(void) const { return at(20)->node(); } + void bw_input_to_cell_weights(loco::Node *node) { at(20)->node(node); } + loco::Node *bw_input_to_output_weights(void) const { return at(21)->node(); } + void bw_input_to_output_weights(loco::Node *node) { at(21)->node(node); } + + loco::Node *bw_recurrent_to_input_weights(void) const { return at(22)->node(); } + void bw_recurrent_to_input_weights(loco::Node *node) { at(22)->node(node); } + loco::Node *bw_recurrent_to_forget_weights(void) const { return at(23)->node(); } + void bw_recurrent_to_forget_weights(loco::Node *node) { at(23)->node(node); } + loco::Node *bw_recurrent_to_cell_weights(void) const { return at(24)->node(); } + void bw_recurrent_to_cell_weights(loco::Node *node) { at(24)->node(node); } + loco::Node *bw_recurrent_to_output_weights(void) const { return at(25)->node(); } + void bw_recurrent_to_output_weights(loco::Node *node) { at(25)->node(node); } + + loco::Node *bw_cell_to_input_weights(void) const { return at(26)->node(); } + void bw_cell_to_input_weights(loco::Node *node) { at(26)->node(node); } + loco::Node *bw_cell_to_forget_weights(void) const { return at(27)->node(); } + void bw_cell_to_forget_weights(loco::Node *node) { at(27)->node(node); } + loco::Node *bw_cell_to_output_weights(void) const { return at(28)->node(); } + void bw_cell_to_output_weights(loco::Node *node) { at(28)->node(node); } + + loco::Node *bw_input_gate_bias(void) const { return at(29)->node(); } + void bw_input_gate_bias(loco::Node *node) { at(29)->node(node); } + loco::Node *bw_forget_gate_bias(void) const { return at(30)->node(); } + void bw_forget_gate_bias(loco::Node *node) { at(30)->node(node); } + loco::Node *bw_cell_gate_bias(void) const { return at(31)->node(); } + void bw_cell_gate_bias(loco::Node *node) { at(31)->node(node); } + loco::Node *bw_output_gate_bias(void) const { return at(32)->node(); } + void bw_output_gate_bias(loco::Node *node) { at(32)->node(node); } + + loco::Node *bw_projection_weights(void) const { return at(33)->node(); } + void bw_projection_weights(loco::Node *node) { at(33)->node(node); } + loco::Node *bw_projection_bias(void) const { return at(34)->node(); } + void bw_projection_bias(loco::Node *node) { at(34)->node(node); } + + loco::Node *fw_activation_state(void) const { return at(35)->node(); } + void fw_activation_state(loco::Node *node) { at(35)->node(node); } + loco::Node *fw_cell_state(void) const { return at(36)->node(); } + void fw_cell_state(loco::Node *node) { at(36)->node(node); } + + loco::Node *bw_activation_state(void) const { return at(37)->node(); } + void bw_activation_state(loco::Node *node) { at(37)->node(node); } + loco::Node *bw_cell_state(void) const { return at(38)->node(); } + void bw_cell_state(loco::Node *node) { at(38)->node(node); } + + loco::Node *auxillary_input(void) const { return at(39)->node(); } + void auxillary_input(loco::Node *node) { at(39)->node(node); } + loco::Node *fw_auxillary_input_to_input_weights(void) const { return at(40)->node(); } + void fw_auxillary_input_to_input_weights(loco::Node *node) { at(40)->node(node); } + loco::Node *fw_auxillary_input_to_forget_weights(void) const { return at(41)->node(); } + void fw_auxillary_input_to_forget_weights(loco::Node *node) { at(41)->node(node); } + loco::Node *fw_auxillary_input_to_cell_weights(void) const { return at(42)->node(); } + void fw_auxillary_input_to_cell_weights(loco::Node *node) { at(42)->node(node); } + loco::Node *fw_auxillary_input_to_output_weights(void) const { return at(43)->node(); } + void fw_auxillary_input_to_output_weights(loco::Node *node) { at(43)->node(node); } + loco::Node *bw_auxillary_input_to_input_weights(void) const { return at(44)->node(); } + void bw_auxillary_input_to_input_weights(loco::Node *node) { at(44)->node(node); } + loco::Node *bw_auxillary_input_to_forget_weights(void) const { return at(45)->node(); } + void bw_auxillary_input_to_forget_weights(loco::Node *node) { at(45)->node(node); } + loco::Node *bw_auxillary_input_to_cell_weights(void) const { return at(46)->node(); } + void bw_auxillary_input_to_cell_weights(loco::Node *node) { at(46)->node(node); } + loco::Node *bw_auxillary_input_to_output_weights(void) const { return at(47)->node(); } + void bw_auxillary_input_to_output_weights(loco::Node *node) { at(47)->node(node); } + +public: + float cell_clip(void) const { return _cell_clip; } + void cell_clip(float cell_clip) { _cell_clip = cell_clip; } + float proj_clip(void) const { return _proj_clip; } + void proj_clip(float proj_clip) { _proj_clip = proj_clip; } + bool merge_outputs(void) const { return _merge_outputs; } + void merge_outputs(bool merge_outputs) { _merge_outputs = merge_outputs; } + bool time_major(void) const { return _time_major; } + void time_major(bool time_major) { _time_major = time_major; } + bool asymmetric_quantize_inputs(void) const { return _asymmetric_quantize_inputs; } + void asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) + { + _asymmetric_quantize_inputs = asymmetric_quantize_inputs; + } + +private: + float _cell_clip{0.0f}; + float _proj_clip{0.0f}; + bool _merge_outputs{false}; + bool _time_major{false}; + bool _asymmetric_quantize_inputs{false}; +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLEBIDIRECTIONALSEQUENCE_LSTM_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleBidirectionalSequenceLSTMOut.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleBidirectionalSequenceLSTMOut.h new file mode 100644 index 000000000..fb2eb0831 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleBidirectionalSequenceLSTMOut.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLE_BIDIRECTIONAL_SEQUENCE_LSTM_OUT_H__ +#define __LUCI_IR_CIRCLE_BIDIRECTIONAL_SEQUENCE_LSTM_OUT_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief Virtual CIRCLEBIDIRECTIONAL_SEQUENCE_LSTM_OUT in Circle + */ +class CircleBidirectionalSequenceLSTMOut final + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLEBIDIRECTIONAL_SEQUENCE_LSTM_OUT>> +{ +public: + loco::Node *input(void) const { return at(0)->node(); } + void input(loco::Node *node) { at(0)->node(node); } + +public: + int32_t index(void) const { return _index; } + void index(int32_t index) { _index = index; } + +private: + int32_t _index{-1}; +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLE_BIDIRECTIONAL_SEQUENCE_LSTM_OUT_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleCast.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleCast.h index 9a89d0b2b..0b793607f 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleCast.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleCast.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleCeil.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleCeil.h index 8a8715dcf..3d7a7ebc7 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleCeil.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleCeil.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleConcatenation.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleConcatenation.h index dea1a4613..2746a0a2e 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleConcatenation.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleConcatenation.h @@ -21,7 +21,7 @@ #include "luci/IR/CircleOpcode.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" #include "luci/IR/VariadicArityNode.h" #include <cassert> @@ -33,12 +33,12 @@ namespace luci * @brief CONCATENATION in Circle */ class CircleConcatenation final - : public VariadicArityNode<CircleNodeImpl<CircleOpcode::CONCATENATION>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + : public VariadicArityNode<CircleNodeImpl<CircleOpcode::CONCATENATION>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: CircleConcatenation(uint32_t arity) - : VariadicArityNode<CircleNodeImpl<CircleOpcode::CONCATENATION>>(arity) + : VariadicArityNode<CircleNodeImpl<CircleOpcode::CONCATENATION>>(arity) { // TODO Support when arity is 0 assert(arity >= 1); diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleConst.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleConst.h index 250282049..3e9a274e0 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleConst.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleConst.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" #include <loco/IR/DataTypeTraits.h> @@ -34,9 +34,6 @@ namespace luci class CircleConst final : public FixedArityNode<0, CircleNodeImpl<CircleOpcode::CIRCLECONST>> { public: - CircleConst() = default; - -public: template <loco::DataType DT> uint32_t size(void) const; template <loco::DataType DT> void size(uint32_t size); template <loco::DataType DT> const typename loco::DataTypeImpl<DT>::Type &at(uint32_t n) const; @@ -47,6 +44,8 @@ public: private: std::vector<uint8_t> _data; + // TODO use _data for STRING and remove _strings + std::vector<std::string> _strings; // for STRING type }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleConv2D.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleConv2D.h index 13657cee4..7c390940e 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleConv2D.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleConv2D.h @@ -24,7 +24,7 @@ #include "luci/IR/AttrStride.h" #include "luci/IR/AttrDilation.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -33,8 +33,8 @@ namespace luci * @brief CONV_2D in Circle */ class CircleConv2D final : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::CONV_2D>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc>, - public LuciNodeMixin<LuciNodeTrait::Bias> + public CircleNodeMixin<CircleNodeTrait::FusedActFunc>, + public CircleNodeMixin<CircleNodeTrait::Bias> { public: loco::Node *input(void) const { return at(0)->node(); } @@ -57,7 +57,7 @@ public: Dilation *dilation(void) { return &_dilation; } private: - Padding _padding = Padding::UNDEFINED; + Padding _padding{Padding::UNDEFINED}; Stride _stride; Dilation _dilation; }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleCos.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleCos.h index 07ced620a..cff04906d 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleCos.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleCos.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleCustom.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleCustom.h index 6c722b766..5709e2cd5 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleCustom.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleCustom.h @@ -29,19 +29,22 @@ namespace luci class CircleCustom final : public VariadicArityNode<CircleNodeImpl<CircleOpcode::CUSTOM>> { public: - CircleCustom(uint32_t arity) : VariadicArityNode<CircleNodeImpl<CircleOpcode::CUSTOM>>(arity) + CircleCustom(uint32_t arity, uint32_t out) + : VariadicArityNode<CircleNodeImpl<CircleOpcode::CUSTOM>>(arity), _output_count(out) { - // TODO Support when arity is 0 - assert(arity >= 1); + // NOTE Custom can have 0 input or 0 output but not both + assert(arity != 0 || out != 0); } public: uint32_t numInputs(void) const { return arity(); } + uint32_t numOutputs(void) const { return _output_count; } public: Node *inputs(uint32_t index) const { return at(index)->node(); } void inputs(uint32_t index, Node *node) { at(index)->node(node); } +public: const std::vector<uint8_t> &custom_options(void) const { return _custom_options; } void custom_options(const std::vector<uint8_t> &custom_options) { @@ -54,6 +57,7 @@ public: private: std::vector<uint8_t> _custom_options; std::string _custom_code; + uint32_t _output_count{0}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleCustomOut.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleCustomOut.h index 36b8e4aed..91a89c151 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleCustomOut.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleCustomOut.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,12 +29,9 @@ namespace luci * @brief Virtual CIRCLECUSTOMOUT in Circle */ class CircleCustomOut final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLECUSTOMOUT>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLECUSTOMOUT>> { public: - CircleCustomOut() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleDensify.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleDensify.h new file mode 100644 index 000000000..7acad0341 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleDensify.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2022 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLE_DENSIFY_H__ +#define __LUCI_IR_CIRCLE_DENSIFY_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief DENSIFY in Circle + */ +class CircleDensify final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::DENSIFY>> +{ +public: + loco::Node *input(void) const { return at(0)->node(); } + void input(loco::Node *node) { at(0)->node(node); } +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLE_DENSIFY_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleDepthToSpace.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleDepthToSpace.h index e19282b97..85b567fb7 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleDepthToSpace.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleDepthToSpace.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,18 +29,18 @@ namespace luci * @brief DEPTH_TO_SPACE in Circle */ class CircleDepthToSpace final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::DEPTH_TO_SPACE>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::DEPTH_TO_SPACE>> { public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } public: - int block_size(void) const { return _block_size; } - void block_size(int block_size) { _block_size = block_size; } + int32_t block_size(void) const { return _block_size; } + void block_size(int32_t block_size) { _block_size = block_size; } private: - int _block_size{0}; + int32_t _block_size{0}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleDepthwiseConv2D.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleDepthwiseConv2D.h index eb058cec1..046aa5908 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleDepthwiseConv2D.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleDepthwiseConv2D.h @@ -25,7 +25,7 @@ #include "luci/IR/AttrPadding.h" #include "luci/IR/AttrStride.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -34,9 +34,9 @@ namespace luci * @brief DEPTHWISE_CONV_2D in Circle */ class CircleDepthwiseConv2D final - : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::DEPTHWISE_CONV_2D>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc>, - public LuciNodeMixin<LuciNodeTrait::Bias> + : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::DEPTHWISE_CONV_2D>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc>, + public CircleNodeMixin<CircleNodeTrait::Bias> { public: loco::Node *input(void) const { return at(0)->node(); } @@ -62,9 +62,9 @@ public: Dilation *dilation(void) { return &_dilation; } private: - Padding _padding = Padding::UNDEFINED; + Padding _padding{Padding::UNDEFINED}; Stride _stride; - int32_t _depth_multiplier = 0; + int32_t _depth_multiplier{0}; Dilation _dilation; }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleDequantize.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleDequantize.h new file mode 100644 index 000000000..c3ee44253 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleDequantize.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCELEDEQUANTIZE_H__ +#define __LUCI_IR_CIRCELEDEQUANTIZE_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief DEQUANTIZE in Circle + */ +class CircleDequantize final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::DEQUANTIZE>> +{ +public: + loco::Node *input(void) const { return at(0)->node(); } + void input(loco::Node *node) { at(0)->node(node); } +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCELEDEQUANTIZE_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleDiv.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleDiv.h index 1d4d3a239..fcc3f427c 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleDiv.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleDiv.h @@ -24,7 +24,7 @@ #include "luci/IR/AttrPadding.h" #include "luci/IR/AttrStride.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -33,12 +33,9 @@ namespace luci * @brief DIV in Circle */ class CircleDiv final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::DIV>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: - CircleDiv() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleElu.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleElu.h index fbb2f3533..721edd9ae 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleElu.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleElu.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleElu final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::ELU>> { public: - CircleElu() = default; - -public: loco::Node *features(void) const { return at(0)->node(); } void features(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleEqual.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleEqual.h index 2087d097a..69697ac7e 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleEqual.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleEqual.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleExp.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleExp.h index 97aecb30a..b8a5d4561 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleExp.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleExp.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleExpandDims.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleExpandDims.h index f70219614..15bfe6a29 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleExpandDims.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleExpandDims.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleExpandDims final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::EXPAND_DIMS>> { public: - CircleExpandDims() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleFakeQuant.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleFakeQuant.h new file mode 100644 index 000000000..9e3159685 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleFakeQuant.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLE_FAKE_QUANT_H__ +#define __LUCI_IR_CIRCLE_FAKE_QUANT_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief FAKE_QUANT in Circle + * @note 'inputs' came from TF.quantize.fake_quant_from_min_max_vars + */ +class CircleFakeQuant final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::FAKE_QUANT>> +{ +public: + loco::Node *inputs(void) const { return at(0)->node(); } + void inputs(loco::Node *node) { at(0)->node(node); } + +public: + float min(void) const { return _min; } + void min(float min) { _min = min; } + + float max(void) const { return _max; } + void max(float max) { _max = max; } + + int32_t num_bits(void) const { return _num_bits; } + void num_bits(int32_t num_bits) { _num_bits = num_bits; } + + bool narrow_range(void) const { return _narrow_range; } + void narrow_range(bool narrow_range) { _narrow_range = narrow_range; } + +private: + float _min{0.0f}; + float _max{0.0f}; + int32_t _num_bits{0}; + bool _narrow_range{false}; +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLEGATHER_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleFill.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleFill.h index bfc65274a..183794d41 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleFill.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleFill.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleFloor.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleFloor.h index 7e10547b6..ce6807e98 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleFloor.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleFloor.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleFloorDiv.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleFloorDiv.h index ba9db010c..bf76e37b6 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleFloorDiv.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleFloorDiv.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleFloorMod.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleFloorMod.h index 4d13717a0..1af0af758 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleFloorMod.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleFloorMod.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleFullyConnected.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleFullyConnected.h index d78f39494..dc5aeb267 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleFullyConnected.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleFullyConnected.h @@ -21,7 +21,7 @@ #include "luci/IR/CircleOpcode.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -30,11 +30,21 @@ namespace luci * @brief FULLY_CONNECTED in Circle */ class CircleFullyConnected final - : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::FULLY_CONNECTED>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc>, - public LuciNodeMixin<LuciNodeTrait::Bias> + : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::FULLY_CONNECTED>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc>, + public CircleNodeMixin<CircleNodeTrait::Bias> { public: + enum class WeightsFormat + { + UNDEFINED, // This is not defined by Circle. This was added to prevent programming error. + + DEFAULT, + SHUFFLED4x16INT8, + SHUFFLED16x1FLOAT32, + }; + +public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } @@ -43,6 +53,17 @@ public: loco::Node *bias(void) const override { return at(2)->node(); } void bias(loco::Node *node) override { at(2)->node(node); } + +public: + WeightsFormat weights_format(void) const { return _weights_format; } + void weights_format(WeightsFormat weights_format) { _weights_format = weights_format; } + + bool keep_num_dims(void) const { return _keep_num_dims; } + void keep_num_dims(bool keep_num_dims) { _keep_num_dims = keep_num_dims; } + +private: + WeightsFormat _weights_format{WeightsFormat::DEFAULT}; + bool _keep_num_dims{false}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleGather.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleGather.h index 1e8c4982a..78fa2fc28 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleGather.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleGather.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -42,7 +42,7 @@ public: void axis(int32_t axis) { _axis = axis; } private: - int32_t _axis = 0; + int32_t _axis{0}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleGatherNd.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleGatherNd.h index 3423a8216..d6f34f1ea 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleGatherNd.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleGatherNd.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleGelu.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleGelu.h new file mode 100644 index 000000000..badfec7cf --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleGelu.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2023 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLEGELU_H__ +#define __LUCI_IR_CIRCLEGELU_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief GELU in Circle + */ +class CircleGelu final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::GELU>> +{ +public: + loco::Node *features(void) const { return at(0)->node(); } + void features(loco::Node *node) { at(0)->node(node); } + +public: + bool approximate(void) const { return _approximate; } + void approximate(bool arg) { _approximate = arg; } + +private: + bool _approximate{false}; +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLEGELU_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleGreater.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleGreater.h index 040a4e338..a03b6c749 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleGreater.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleGreater.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleGreaterEqual.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleGreaterEqual.h index 82bdab212..e435320b2 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleGreaterEqual.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleGreaterEqual.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,7 +29,7 @@ namespace luci * @brief GREATER EQUAL in Circle */ class CircleGreaterEqual final - : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::GREATER_EQUAL>> + : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::GREATER_EQUAL>> { public: loco::Node *x(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleHardSwish.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleHardSwish.h new file mode 100644 index 000000000..18652a07d --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleHardSwish.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2023 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLEHARDSWISH_H__ +#define __LUCI_IR_CIRCLEHARDSWISH_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief HardSwish in Circle + */ +class CircleHardSwish final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::HARD_SWISH>> +{ +public: + loco::Node *features(void) const { return at(0)->node(); } + void features(loco::Node *node) { at(0)->node(node); } +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLEHARDSWISH_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleIf.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleIf.h index 2f9eac211..1c037a406 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleIf.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleIf.h @@ -34,7 +34,7 @@ class CircleIf final : public VariadicArityNode<CircleNodeImpl<CircleOpcode::IF> { public: CircleIf(uint32_t arity, uint32_t out) - : VariadicArityNode<CircleNodeImpl<CircleOpcode::IF>>(arity + 1), _output_count(out) + : VariadicArityNode<CircleNodeImpl<CircleOpcode::IF>>(arity + 1), _output_count(out) { assert(arity > 0); assert(out > 0); diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleIfOut.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleIfOut.h index 3654e943b..5adaaa447 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleIfOut.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleIfOut.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleIfOut final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLEIFOUT>> { public: - CircleIfOut() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleInput.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleInput.h index 4a7d36a4e..e0be9aa6e 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleInput.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleInput.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" #include <loco/IR/DataTypeTraits.h> #include <loco/IR/GraphInputIndex.h> @@ -35,16 +35,13 @@ namespace luci class CircleInput final : public FixedArityNode<0, CircleNodeImpl<CircleOpcode::CIRCLEINPUT>> { public: - CircleInput() = default; - -public: void index(const loco::GraphInputIndex &index); loco::GraphInputIndex index(void) const; bool indexed(void) const { return _index != -1; } private: - int64_t _index = -1; // Uninitialized + int64_t _index{-1}; // Uninitialized }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleInstanceNorm.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleInstanceNorm.h index db0faa05e..65c34194d 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleInstanceNorm.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleInstanceNorm.h @@ -21,7 +21,7 @@ #include "luci/IR/CircleOpcode.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -30,8 +30,8 @@ namespace luci * @brief INSTANCE_NORM in Circle */ class CircleInstanceNorm final - : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::INSTANCE_NORM>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::INSTANCE_NORM>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: /// @note Currently only support FLOAT32 as input node @@ -44,11 +44,12 @@ public: loco::Node *beta(void) const { return at(2)->node(); } void beta(loco::Node *node) { at(2)->node(node); } +public: float epsilon() const { return _epsilon; } void epsilon(float epsilon) { _epsilon = epsilon; } private: - float _epsilon = 1e-05; + float _epsilon{1e-05}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleL2Normalize.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleL2Normalize.h index efa932d95..eb2b372ce 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleL2Normalize.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleL2Normalize.h @@ -21,7 +21,7 @@ #include "luci/IR/CircleOpcode.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -30,8 +30,8 @@ namespace luci * @brief L2_NORMALIZATION in Circle */ class CircleL2Normalize final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::L2_NORMALIZATION>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::L2_NORMALIZATION>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: loco::Node *x(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleL2Pool2D.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleL2Pool2D.h index 7c76ee5d0..624d29e9e 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleL2Pool2D.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleL2Pool2D.h @@ -24,7 +24,7 @@ #include "luci/IR/AttrPadding.h" #include "luci/IR/AttrStride.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -33,15 +33,13 @@ namespace luci * @brief L2_POOL_2D in Circle */ class CircleL2Pool2D final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::L2_POOL_2D>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: - CircleL2Pool2D() : _padding(Padding::UNDEFINED) { /* empty */} - -public: loco::Node *value(void) const { return at(0)->node(); } void value(loco::Node *node) { at(0)->node(node); } +public: Padding padding() const { return _padding; } void padding(Padding padding) { _padding = padding; } @@ -52,7 +50,7 @@ public: Stride *stride(void) { return &_stride; } private: - Padding _padding; + Padding _padding{Padding::UNDEFINED}; Stride _stride; Filter _filter; }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLeakyRelu.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLeakyRelu.h index d6ac97fc0..c8e93af91 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLeakyRelu.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLeakyRelu.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,17 +31,15 @@ namespace luci class CircleLeakyRelu final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::LEAKY_RELU>> { public: - CircleLeakyRelu() = default; - -public: loco::Node *features(void) const { return at(0)->node(); } void features(loco::Node *node) { at(0)->node(node); } +public: float alpha() const { return _alpha; } void alpha(float alpha) { _alpha = alpha; } private: - float _alpha = 0.2f; + float _alpha{0.2f}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLess.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLess.h index cd6cf1872..7adf67842 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLess.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLess.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLessEqual.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLessEqual.h index 4c7c6a49b..eb8962494 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLessEqual.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLessEqual.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLocalResponseNormalization.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLocalResponseNormalization.h index 8ad2b40fd..4d324700e 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLocalResponseNormalization.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLocalResponseNormalization.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,7 +29,7 @@ namespace luci * @brief LOCAL_RESPONSE_NORMALIZATION in Circle */ class CircleLocalResponseNormalization final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::LOCAL_RESPONSE_NORMALIZATION>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::LOCAL_RESPONSE_NORMALIZATION>> { public: loco::Node *input(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLog.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLog.h index aeb13fed9..2cc57ce2d 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLog.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLog.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogSoftmax.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogSoftmax.h index 5dfd2c1f9..b73ff7c2a 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogSoftmax.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogSoftmax.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalAnd.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalAnd.h index 975f6dbc7..9943c71cd 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalAnd.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalAnd.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalNot.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalNot.h index 749dbe518..369a3e7bf 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalNot.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalNot.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalOr.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalOr.h index 570be57af..c54ec3ebf 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalOr.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogicalOr.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogistic.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogistic.h index 8328cb328..1f95e0f77 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleLogistic.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleLogistic.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleLogistic final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::LOGISTIC>> { public: - CircleLogistic() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleMatrixDiag.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleMatrixDiag.h index dca6538c3..f8bf259f9 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleMatrixDiag.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleMatrixDiag.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleMatrixSetDiag.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleMatrixSetDiag.h index c1f5f3023..76aeaff40 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleMatrixSetDiag.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleMatrixSetDiag.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,7 +29,7 @@ namespace luci * @brief MATRIX_SET_DIAG in Circle */ class CircleMatrixSetDiag final - : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::MATRIX_SET_DIAG>> + : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::MATRIX_SET_DIAG>> { public: loco::Node *input(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleMaxPool2D.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleMaxPool2D.h index 1eb6532ff..557240d54 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleMaxPool2D.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleMaxPool2D.h @@ -24,7 +24,7 @@ #include "luci/IR/AttrPadding.h" #include "luci/IR/AttrStride.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -33,15 +33,13 @@ namespace luci * @brief MAX_POOL_2D in Circle */ class CircleMaxPool2D final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::MAX_POOL_2D>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: - CircleMaxPool2D() : _padding(Padding::UNDEFINED) { /* empty */} - -public: loco::Node *value(void) const { return at(0)->node(); } void value(loco::Node *node) { at(0)->node(node); } +public: Padding padding() const { return _padding; } void padding(Padding padding) { _padding = padding; } @@ -52,7 +50,7 @@ public: Stride *stride(void) { return &_stride; } private: - Padding _padding; + Padding _padding{Padding::UNDEFINED}; Stride _stride; Filter _filter; }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleMaximum.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleMaximum.h index 6f789bc14..317cea308 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleMaximum.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleMaximum.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleMean.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleMean.h index 7f8aeb5aa..f56e4f4c0 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleMean.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleMean.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -42,7 +42,7 @@ public: void keep_dims(bool keep_dims) { _keep_dims = keep_dims; } private: - bool _keep_dims = false; + bool _keep_dims{false}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleMinimum.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleMinimum.h index 79d5a6f17..959d9c93b 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleMinimum.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleMinimum.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleMirrorPad.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleMirrorPad.h index 68db8f6f3..c69e8f7c1 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleMirrorPad.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleMirrorPad.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" #include "luci/IR/AttrMirrorPadMode.h" namespace luci @@ -32,9 +32,6 @@ namespace luci class CircleMirrorPad final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::MIRROR_PAD>> { public: - CircleMirrorPad() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleMul.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleMul.h index 67e897170..85ed694b3 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleMul.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleMul.h @@ -21,7 +21,7 @@ #include "luci/IR/CircleOpcode.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -30,7 +30,7 @@ namespace luci * @brief MUL in Circle */ class CircleMul final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::MUL>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: loco::Node *x(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleNeg.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleNeg.h index 4149ac4a7..adea3fb83 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleNeg.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleNeg.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV4.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV4.h index 69f3368c0..b47404bb0 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV4.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV4.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,7 +29,7 @@ namespace luci * @brief NON_MAX_SUPPRESSION_V4 in Circle */ class CircleNonMaxSuppressionV4 final - : public FixedArityNode<5, CircleNodeImpl<CircleOpcode::NON_MAX_SUPPRESSION_V4>> + : public FixedArityNode<5, CircleNodeImpl<CircleOpcode::NON_MAX_SUPPRESSION_V4>> { public: loco::Node *boxes(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV4Out.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV4Out.h index a24dc3e9c..7e6923b5e 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV4Out.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV4Out.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,12 +29,9 @@ namespace luci * @brief Virtual NONMAXSUPPRESSIONV4OUT in Circle */ class CircleNonMaxSuppressionV4Out final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLENONMAXSUPPRESSIONV4OUT>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLENONMAXSUPPRESSIONV4OUT>> { public: - CircleNonMaxSuppressionV4Out() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV5.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV5.h index 52d682147..77086ede7 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV5.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV5.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,7 +29,7 @@ namespace luci * @brief NON_MAX_SUPPRESSION_V5 in Circle */ class CircleNonMaxSuppressionV5 final - : public FixedArityNode<6, CircleNodeImpl<CircleOpcode::NON_MAX_SUPPRESSION_V5>> + : public FixedArityNode<6, CircleNodeImpl<CircleOpcode::NON_MAX_SUPPRESSION_V5>> { public: loco::Node *boxes(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV5Out.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV5Out.h index 0c6989cc7..63d061f11 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV5Out.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleNonMaxSuppressionV5Out.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,12 +29,9 @@ namespace luci * @brief Virtual NONMAXSUPPRESSIONV5OUT in Circle */ class CircleNonMaxSuppressionV5Out final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLENONMAXSUPPRESSIONV5OUT>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLENONMAXSUPPRESSIONV5OUT>> { public: - CircleNonMaxSuppressionV5Out() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleNotEqual.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleNotEqual.h index cca7a5e22..add6a0747 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleNotEqual.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleNotEqual.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleOneHot.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleOneHot.h index 665e01d48..b3eb0f436 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleOneHot.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleOneHot.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -48,7 +48,7 @@ public: void axis(int32_t axis) { _axis = axis; } private: - int32_t _axis = -1; + int32_t _axis{-1}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleOutput.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleOutput.h index 67e55f1a1..eb02f824e 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleOutput.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleOutput.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" #include <loco/IR/GraphOutputIndex.h> @@ -34,8 +34,6 @@ namespace luci class CircleOutput final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLEOUTPUT>> { public: - CircleOutput() = default; - void index(const loco::GraphOutputIndex &index); loco::GraphOutputIndex index(void) const; @@ -46,7 +44,7 @@ public: void from(loco::Node *node) { at(0)->node(node); } private: - int64_t _index = -1; // Uninitialized + int64_t _index{-1}; // Uninitialized }; /** @@ -54,7 +52,7 @@ private: */ // TODO remove CircleOutputDummy class CircleOutputDummy final - : public FixedArityNode<0, CircleNodeImpl<CircleOpcode::CIRCLEOUTPUTDUMMY>> + : public FixedArityNode<0, CircleNodeImpl<CircleOpcode::CIRCLEOUTPUTDUMMY>> { public: CircleOutputDummy() = default; @@ -64,7 +62,7 @@ public: * @brief CircleOutputExclude is used to specifying not exported nodes */ class CircleOutputExclude final - : public FixedArityNode<0, CircleNodeImpl<CircleOpcode::CIRCLEOUTPUTEXCLUDE>> + : public FixedArityNode<0, CircleNodeImpl<CircleOpcode::CIRCLEOUTPUTEXCLUDE>> { public: CircleOutputExclude() = default; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CirclePRelu.h b/compiler/luci/lang/include/luci/IR/Nodes/CirclePRelu.h index 693777512..3c5559db2 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CirclePRelu.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CirclePRelu.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CirclePRelu final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::PRELU>> { public: - CirclePRelu() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CirclePad.h b/compiler/luci/lang/include/luci/IR/Nodes/CirclePad.h index 31599bda0..ede217789 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CirclePad.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CirclePad.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CirclePad final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::PAD>> { public: - CirclePad() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CirclePadV2.h b/compiler/luci/lang/include/luci/IR/Nodes/CirclePadV2.h index 563cfd9a4..644e2bb27 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CirclePadV2.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CirclePadV2.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CirclePadV2 final : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::PADV2>> { public: - CirclePadV2() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CirclePow.h b/compiler/luci/lang/include/luci/IR/Nodes/CirclePow.h index 006e3dd86..40c5a829d 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CirclePow.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CirclePow.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CirclePow final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::POW>> { public: - CirclePow() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleQuantize.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleQuantize.h new file mode 100644 index 000000000..8018a76c2 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleQuantize.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCELEQUANTIZE_H__ +#define __LUCI_IR_CIRCELEQUANTIZE_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief QUANTIZE in Circle + */ +class CircleQuantize final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::QUANTIZE>> +{ +public: + loco::Node *input(void) const { return at(0)->node(); } + void input(loco::Node *node) { at(0)->node(node); } +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCELEDUANTIZE_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleRange.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleRange.h index 977a37a52..56f8a2eba 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleRange.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleRange.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleRank.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleRank.h index ba6d67f69..034f251bc 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleRank.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleRank.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceAny.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceAny.h index 0456be863..c64dbbdf8 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceAny.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceAny.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -42,7 +42,7 @@ public: void keep_dims(bool keep_dims) { _keep_dims = keep_dims; } private: - bool _keep_dims = false; + bool _keep_dims{false}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceMax.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceMax.h index 925c977e5..97cbecd08 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceMax.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceMax.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -42,7 +42,7 @@ public: void keep_dims(bool keep_dims) { _keep_dims = keep_dims; } private: - bool _keep_dims = false; + bool _keep_dims{false}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceMin.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceMin.h index fd789ae5e..33708928f 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceMin.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceMin.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -42,7 +42,7 @@ public: void keep_dims(bool keep_dims) { _keep_dims = keep_dims; } private: - bool _keep_dims = false; + bool _keep_dims{false}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceProd.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceProd.h index b7d226255..3689ee532 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceProd.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleReduceProd.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -42,7 +42,7 @@ public: void keep_dims(bool keep_dims) { _keep_dims = keep_dims; } private: - bool _keep_dims = false; + bool _keep_dims{false}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleRelu.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleRelu.h index 91272d2bf..6148caa03 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleRelu.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleRelu.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleRelu final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::RELU>> { public: - CircleRelu() = default; - -public: loco::Node *features(void) const { return at(0)->node(); } void features(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleRelu6.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleRelu6.h index b4274ded9..0fa25e873 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleRelu6.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleRelu6.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleRelu6 final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::RELU6>> { public: - CircleRelu6() = default; - -public: loco::Node *features(void) const { return at(0)->node(); } void features(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleReluN1To1.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleReluN1To1.h index a5c5710c2..13c0d166f 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleReluN1To1.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleReluN1To1.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleReluN1To1 final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::RELU_N1_TO_1>> { public: - CircleReluN1To1() = default; - -public: loco::Node *features(void) const { return at(0)->node(); } void features(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleReshape.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleReshape.h index b13144f7e..090df4044 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleReshape.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleReshape.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,14 +31,11 @@ namespace luci class CircleReshape final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::RESHAPE>> { public: - CircleReshape() = default; - -public: loco::Node *tensor(void) const { return at(0)->node(); } void tensor(loco::Node *node) { at(0)->node(node); } // NOTE shape is optional and can be CircleConst or any other type - // and also can be CircleOutputDummy when reshape option does not exist + // and also should be CircleOutputDummy when reshape option does not exist loco::Node *shape(void) const { return at(1)->node(); } void shape(loco::Node *node) { at(1)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleResizeBilinear.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleResizeBilinear.h index 3c8223338..091916a2b 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleResizeBilinear.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleResizeBilinear.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,18 +29,16 @@ namespace luci * @brief RESIZE_BILINEAR in Circle */ class CircleResizeBilinear final - : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::RESIZE_BILINEAR>> + : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::RESIZE_BILINEAR>> { public: - CircleResizeBilinear() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } loco::Node *size(void) const { return at(1)->node(); } void size(loco::Node *node) { at(1)->node(node); } +public: bool align_corners() const { return _align_corners; } void align_corners(bool value) { _align_corners = value; } @@ -48,8 +46,8 @@ public: void half_pixel_centers(bool value) { _half_pixel_centers = value; } private: - bool _align_corners = false; - bool _half_pixel_centers = false; + bool _align_corners{false}; + bool _half_pixel_centers{false}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleResizeNearestNeighbor.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleResizeNearestNeighbor.h index dc32ebee7..ab880d767 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleResizeNearestNeighbor.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleResizeNearestNeighbor.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,23 +29,21 @@ namespace luci * @brief RESIZE_NEAREST_NEIGHBOR in Circle */ class CircleResizeNearestNeighbor final - : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::RESIZE_NEAREST_NEIGHBOR>> + : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::RESIZE_NEAREST_NEIGHBOR>> { public: - CircleResizeNearestNeighbor() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } loco::Node *size(void) const { return at(1)->node(); } void size(loco::Node *node) { at(1)->node(node); } +public: bool align_corners() const { return _align_corners; } void align_corners(bool value) { _align_corners = value; } private: - bool _align_corners = false; + bool _align_corners{false}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleReverseSequence.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleReverseSequence.h index b0766dd3e..5f089a768 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleReverseSequence.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleReverseSequence.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,12 +29,9 @@ namespace luci * @brief REVERSE_SEQUENCE in Circle */ class CircleReverseSequence final - : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::REVERSE_SEQUENCE>> + : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::REVERSE_SEQUENCE>> { public: - CircleReverseSequence() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } @@ -42,15 +39,15 @@ public: void seq_lengths(loco::Node *node) { at(1)->node(node); } public: - int seq_axis(void) const { return _seq_axis; } - void seq_axis(int seq_axis) { _seq_axis = seq_axis; } + int32_t seq_axis(void) const { return _seq_axis; } + void seq_axis(int32_t seq_axis) { _seq_axis = seq_axis; } - int batch_axis(void) const { return _batch_axis; } - void batch_axis(int batch_axis) { _batch_axis = batch_axis; } + int32_t batch_axis(void) const { return _batch_axis; } + void batch_axis(int32_t batch_axis) { _batch_axis = batch_axis; } private: - int _seq_axis{0}; - int _batch_axis{0}; + int32_t _seq_axis{0}; + int32_t _batch_axis{0}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleReverseV2.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleReverseV2.h index 71d9f65aa..96b6a793d 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleReverseV2.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleReverseV2.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleRound.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleRound.h index 30296ce9e..e340266ed 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleRound.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleRound.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleRound final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::ROUND>> { public: - CircleRound() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleRsqrt.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleRsqrt.h index 873397bce..7907f326b 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleRsqrt.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleRsqrt.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleRsqrt final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::RSQRT>> { public: - CircleRsqrt() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSVDF.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSVDF.h new file mode 100644 index 000000000..839d11e04 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSVDF.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2022 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLE_SVDF_H__ +#define __LUCI_IR_CIRCLE_SVDF_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/LuciNodeMixins.h" + +namespace luci +{ + +/** + * @brief SVDF in Circle + */ +class CircleSVDF final : public FixedArityNode<5, CircleNodeImpl<CircleOpcode::SVDF>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> +{ +public: + CircleSVDF() = default; + +public: + loco::Node *input(void) const { return at(0)->node(); } + void input(loco::Node *node) { at(0)->node(node); } + + loco::Node *weight_feature(void) const { return at(1)->node(); } + void weight_feature(loco::Node *node) { at(1)->node(node); } + + loco::Node *weight_time(void) const { return at(2)->node(); } + void weight_time(loco::Node *node) { at(2)->node(node); } + + loco::Node *bias(void) const { return at(3)->node(); } + void bias(loco::Node *node) { at(3)->node(node); } + + loco::Node *input_activation_state(void) const { return at(4)->node(); } + void input_activation_state(loco::Node *node) { at(4)->node(node); } + +public: + bool asymmetric_quantize_inputs() const { return _asymmetric_quantize_inputs; } + void asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) + { + _asymmetric_quantize_inputs = asymmetric_quantize_inputs; + } + + int32_t svdf_rank() const { return _rank; } + void svdf_rank(int32_t svdf_rank) { _rank = svdf_rank; } + +private: + bool _asymmetric_quantize_inputs = false; + int32_t _rank = 0; +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLE_SVDF_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleScatterNd.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleScatterNd.h index 9f93a0a80..fda3abafc 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleScatterNd.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleScatterNd.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSegmentSum.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSegmentSum.h index 416d617b2..e7227e9ee 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSegmentSum.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSegmentSum.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleSegmentSum final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::SEGMENT_SUM>> { public: - CircleSegmentSum() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSelect.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSelect.h index 727647168..6f778d72d 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSelect.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSelect.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleSelect final : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::SELECT>> { public: - CircleSelect() = default; - -public: loco::Node *condition(void) const { return at(0)->node(); } void condition(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSelectV2.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSelectV2.h index 7ac3c0524..7969cc2aa 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSelectV2.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSelectV2.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleSelectV2 final : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::SELECT_V2>> { public: - CircleSelectV2() = default; - -public: loco::Node *condition(void) const { return at(0)->node(); } void condition(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleShape.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleShape.h index ff20ce684..903894dbd 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleShape.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleShape.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleShape final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::SHAPE>> { public: - CircleShape() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSin.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSin.h index 5624db253..25dc18b0d 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSin.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSin.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSlice.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSlice.h index a2113643d..98556d7a6 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSlice.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSlice.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSoftmax.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSoftmax.h index 7166a329b..d10cb1682 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSoftmax.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSoftmax.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSpaceToBatchND.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSpaceToBatchND.h index 042ebffcd..ef715c6d0 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSpaceToBatchND.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSpaceToBatchND.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,7 +29,7 @@ namespace luci * @brief SPACE_TO_BATCH_ND in Circle */ class CircleSpaceToBatchND final - : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::SPACE_TO_BATCH_ND>> + : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::SPACE_TO_BATCH_ND>> { public: loco::Node *input(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSpaceToDepth.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSpaceToDepth.h index 420a4cb96..387e0d80f 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSpaceToDepth.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSpaceToDepth.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,18 +29,18 @@ namespace luci * @brief SPACE_TO_DEPTH in Circle */ class CircleSpaceToDepth final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::SPACE_TO_DEPTH>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::SPACE_TO_DEPTH>> { public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } public: - int block_size(void) const { return _block_size; } - void block_size(int block_size) { _block_size = block_size; } + int32_t block_size(void) const { return _block_size; } + void block_size(int32_t block_size) { _block_size = block_size; } private: - int _block_size{0}; + int32_t _block_size{0}; }; } // namespace luci diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSparseToDense.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSparseToDense.h index 7e80304b0..94a20c064 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSparseToDense.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSparseToDense.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,7 +29,7 @@ namespace luci * @brief SPARSE_TO_DENSE in Circle */ class CircleSparseToDense final - : public FixedArityNode<4, CircleNodeImpl<CircleOpcode::SPARSE_TO_DENSE>> + : public FixedArityNode<4, CircleNodeImpl<CircleOpcode::SPARSE_TO_DENSE>> { public: loco::Node *indices(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSplit.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSplit.h index 0eda19501..0cb953131 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSplit.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSplit.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitOut.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitOut.h index 6bf4a9fef..a507740e4 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitOut.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitOut.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleSplitOut final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLESPLITOUT>> { public: - CircleSplitOut() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitV.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitV.h index 1b7d55534..cb02cbbcf 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitV.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitV.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitVOut.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitVOut.h index d3b2f1e5a..adf79f30c 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitVOut.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSplitVOut.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,12 +29,9 @@ namespace luci * @brief Virtual CIRCLESPLITVOUT in Circle */ class CircleSplitVOut final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLESPLITVOUT>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLESPLITVOUT>> { public: - CircleSplitVOut() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSqrt.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSqrt.h index c96ca8498..b76bd1ad5 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSqrt.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSqrt.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleSqrt final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::SQRT>> { public: - CircleSqrt() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSquare.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSquare.h index a29edfe82..3f9228b3b 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSquare.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSquare.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleSquare final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::SQUARE>> { public: - CircleSquare() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSquaredDifference.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSquaredDifference.h index b5b39f920..355c9f3d3 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSquaredDifference.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSquaredDifference.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,12 +29,9 @@ namespace luci * @brief SQUARED_DIFFERENCE in Circle */ class CircleSquaredDifference final - : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::SQUARED_DIFFERENCE>> + : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::SQUARED_DIFFERENCE>> { public: - CircleSquaredDifference() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSqueeze.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSqueeze.h index f175f1411..ba71ff217 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSqueeze.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSqueeze.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleSqueeze final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::SQUEEZE>> { public: - CircleSqueeze() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleStridedSlice.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleStridedSlice.h index 98799fec1..6a4155ef1 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleStridedSlice.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleStridedSlice.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,7 +29,7 @@ namespace luci * @brief STRIDED_SLICE in Circle */ class CircleStridedSlice final - : public FixedArityNode<4, CircleNodeImpl<CircleOpcode::STRIDED_SLICE>> + : public FixedArityNode<4, CircleNodeImpl<CircleOpcode::STRIDED_SLICE>> { public: loco::Node *input(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSub.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSub.h index 08208f942..d9aaa44e5 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSub.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSub.h @@ -21,7 +21,7 @@ #include "luci/IR/CircleOpcode.h" #include "luci/IR/AttrFusedActFunc.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -30,12 +30,9 @@ namespace luci * @brief SUB in Circle */ class CircleSub final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::SUB>>, - public LuciNodeMixin<LuciNodeTrait::FusedActFunc> + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> { public: - CircleSub() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleSum.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleSum.h index 21faa76fe..a72e18f54 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleSum.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleSum.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleTanh.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleTanh.h index f7444921f..2036a7301 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleTanh.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleTanh.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleTanh final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::TANH>> { public: - CircleTanh() = default; - -public: loco::Node *x(void) const { return at(0)->node(); } void x(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleTile.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleTile.h index 96e1f69c6..1ec2f5e82 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleTile.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleTile.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleTile final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::TILE>> { public: - CircleTile() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleTopKV2.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleTopKV2.h index 3b2b5abb7..0bf78c3ee 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleTopKV2.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleTopKV2.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleTopKV2 final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::TOPK_V2>> { public: - CircleTopKV2() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleTopKV2Out.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleTopKV2Out.h index 5a6dd0c02..f1a6b4a41 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleTopKV2Out.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleTopKV2Out.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,12 +29,9 @@ namespace luci * @brief Virtual CIRCLETOPKV2OUT in Circle */ class CircleTopKV2Out final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLETOPKV2OUT>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLETOPKV2OUT>> { public: - CircleTopKV2Out() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleTranspose.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleTranspose.h index 095cd6746..72ce0738c 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleTranspose.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleTranspose.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,13 +31,7 @@ namespace luci class CircleTranspose final : public FixedArityNode<2, CircleNodeImpl<CircleOpcode::TRANSPOSE>> { public: - CircleTranspose() = default; - -public: - /// @brief Get the input node to transpose loco::Node *a(void) const { return at(0)->node(); } - - /// @brief Set the input node to transpose void a(loco::Node *node) { at(0)->node(node); } loco::Node *perm(void) const { return at(1)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleTransposeConv.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleTransposeConv.h index e355102d6..8c6f04a58 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleTransposeConv.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleTransposeConv.h @@ -22,7 +22,7 @@ #include "luci/IR/AttrPadding.h" #include "luci/IR/AttrStride.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -34,8 +34,9 @@ namespace luci * 'out' acutally means 'out' and 'in' of the this node. */ class CircleTransposeConv final - : public FixedArityNode<4, CircleNodeImpl<CircleOpcode::TRANSPOSE_CONV>>, - public LuciNodeMixin<LuciNodeTrait::Bias> + : public FixedArityNode<4, CircleNodeImpl<CircleOpcode::TRANSPOSE_CONV>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc>, + public CircleNodeMixin<CircleNodeTrait::Bias> { public: loco::Node *inputSizes(void) const { return at(0)->node(); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleUnidirectionalSequenceLSTM.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleUnidirectionalSequenceLSTM.h new file mode 100644 index 000000000..7b9e445d3 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleUnidirectionalSequenceLSTM.h @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLEUNIDIRECTIONALSEQUENCELSTM_H__ +#define __LUCI_IR_CIRCLEUNIDIRECTIONALSEQUENCELSTM_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/AttrFusedActFunc.h" +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief UNIDIRECTIONAL_SEQUENCE_LSTM in Circle + */ +class CircleUnidirectionalSequenceLSTM final + : public FixedArityNode<24, CircleNodeImpl<CircleOpcode::UNIDIRECTIONAL_SEQUENCE_LSTM>>, + public CircleNodeMixin<CircleNodeTrait::FusedActFunc> +{ +public: + loco::Node *input(void) const { return at(0)->node(); } + void input(loco::Node *node) { at(0)->node(node); } + + loco::Node *input_to_input_weights(void) const { return at(1)->node(); } + void input_to_input_weights(loco::Node *node) { at(1)->node(node); } + loco::Node *input_to_forget_weights(void) const { return at(2)->node(); } + void input_to_forget_weights(loco::Node *node) { at(2)->node(node); } + loco::Node *input_to_cell_weights(void) const { return at(3)->node(); } + void input_to_cell_weights(loco::Node *node) { at(3)->node(node); } + loco::Node *input_to_output_weights(void) const { return at(4)->node(); } + void input_to_output_weights(loco::Node *node) { at(4)->node(node); } + + loco::Node *recurrent_to_input_weights(void) const { return at(5)->node(); } + void recurrent_to_input_weights(loco::Node *node) { at(5)->node(node); } + loco::Node *recurrent_to_forget_weights(void) const { return at(6)->node(); } + void recurrent_to_forget_weights(loco::Node *node) { at(6)->node(node); } + loco::Node *recurrent_to_cell_weights(void) const { return at(7)->node(); } + void recurrent_to_cell_weights(loco::Node *node) { at(7)->node(node); } + loco::Node *recurrent_to_output_weights(void) const { return at(8)->node(); } + void recurrent_to_output_weights(loco::Node *node) { at(8)->node(node); } + + loco::Node *cell_to_input_weights(void) const { return at(9)->node(); } + void cell_to_input_weights(loco::Node *node) { at(9)->node(node); } + loco::Node *cell_to_forget_weights(void) const { return at(10)->node(); } + void cell_to_forget_weights(loco::Node *node) { at(10)->node(node); } + loco::Node *cell_to_output_weights(void) const { return at(11)->node(); } + void cell_to_output_weights(loco::Node *node) { at(11)->node(node); } + + loco::Node *input_gate_bias(void) const { return at(12)->node(); } + void input_gate_bias(loco::Node *node) { at(12)->node(node); } + loco::Node *forget_gate_bias(void) const { return at(13)->node(); } + void forget_gate_bias(loco::Node *node) { at(13)->node(node); } + loco::Node *cell_gate_bias(void) const { return at(14)->node(); } + void cell_gate_bias(loco::Node *node) { at(14)->node(node); } + loco::Node *output_gate_bias(void) const { return at(15)->node(); } + void output_gate_bias(loco::Node *node) { at(15)->node(node); } + + loco::Node *projection_weights(void) const { return at(16)->node(); } + void projection_weights(loco::Node *node) { at(16)->node(node); } + loco::Node *projection_bias(void) const { return at(17)->node(); } + void projection_bias(loco::Node *node) { at(17)->node(node); } + + loco::Node *output_state(void) const { return at(18)->node(); } + void output_state(loco::Node *node) { at(18)->node(node); } + loco::Node *cell_state(void) const { return at(19)->node(); } + void cell_state(loco::Node *node) { at(19)->node(node); } + + loco::Node *input_layer_norm_coefficients(void) const { return at(20)->node(); } + void input_layer_norm_coefficients(loco::Node *node) { at(20)->node(node); } + loco::Node *forget_layer_norm_coefficients(void) const { return at(21)->node(); } + void forget_layer_norm_coefficients(loco::Node *node) { at(21)->node(node); } + loco::Node *cell_layer_norm_coefficients(void) const { return at(22)->node(); } + void cell_layer_norm_coefficients(loco::Node *node) { at(22)->node(node); } + loco::Node *output_layer_norm_coefficients(void) const { return at(23)->node(); } + void output_layer_norm_coefficients(loco::Node *node) { at(23)->node(node); } + +public: + float cell_clip(void) const { return _cell_clip; } + void cell_clip(float cell_clip) { _cell_clip = cell_clip; } + float proj_clip(void) const { return _proj_clip; } + void proj_clip(float proj_clip) { _proj_clip = proj_clip; } + bool time_major(void) const { return _time_major; } + void time_major(bool time_major) { _time_major = time_major; } + bool asymmetric_quantize_inputs(void) const { return _asymmetric_quantize_inputs; } + void asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) + { + _asymmetric_quantize_inputs = asymmetric_quantize_inputs; + } + +private: + float _cell_clip{0.0f}; + float _proj_clip{0.0f}; + bool _time_major{false}; + bool _asymmetric_quantize_inputs{false}; +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLEUNIDIRECTIONALSEQUENCELSTM_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleUnique.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleUnique.h index 719a72362..2dd48b2f9 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleUnique.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleUnique.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -36,7 +36,7 @@ public: public: loco::DataType idx_out_type(void) const { return _idx_out_type; } - void output_type(loco::DataType ot) { _idx_out_type = ot; } + void idx_out_type(loco::DataType ot) { _idx_out_type = ot; } private: loco::DataType _idx_out_type{loco::DataType::S32}; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleUniqueOut.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleUniqueOut.h index f846403e0..233351860 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleUniqueOut.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleUniqueOut.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,12 +29,9 @@ namespace luci * @brief Virtual CIRCLEUNIQUEOUT in Circle */ class CircleUniqueOut final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLEUNIQUEOUT>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLEUNIQUEOUT>> { public: - CircleUniqueOut() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleUnpack.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleUnpack.h index cb91d7e6a..fd0c66ce0 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleUnpack.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleUnpack.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleUnpack final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::UNPACK>> { public: - CircleUnpack() = default; - -public: loco::Node *value(void) const { return at(0)->node(); } void value(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleUnpackOut.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleUnpackOut.h index 6f24578a1..640d2f1bb 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleUnpackOut.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleUnpackOut.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -29,12 +29,9 @@ namespace luci * @brief Virtual CIRCLEUNPACKOUT in Circle */ class CircleUnpackOut final - : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLEUNPACKOUT>> + : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLEUNPACKOUT>> { public: - CircleUnpackOut() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleVariable.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleVariable.h new file mode 100644 index 000000000..8c15b66c9 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleVariable.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2022 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_CIRCLE_VARIABLE_H__ +#define __LUCI_IR_CIRCLE_VARIABLE_H__ + +#include "luci/IR/CircleNodeDecl.h" +#include "luci/IR/CircleOpcode.h" + +#include "luci/IR/CircleNodeMixins.h" + +namespace luci +{ + +/** + * @brief Virtual CircleVariable in Circle for 'variable' Tensor + */ +class CircleVariable final : public FixedArityNode<0, CircleNodeImpl<CircleOpcode::CIRCLEVARIABLE>> +{ +public: + CircleVariable() = default; +}; + +} // namespace luci + +#endif // __LUCI_IR_CIRCLE_VARIABLE_H__ diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleWhere.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleWhere.h index 51eda3d6e..8895bcbbd 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleWhere.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleWhere.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" #include <cassert> @@ -33,9 +33,6 @@ namespace luci class CircleWhere final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::WHERE>> { public: - CircleWhere() = default; - -public: loco::Node *condition() const { return at(0)->node(); } void condition(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleWhile.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleWhile.h index 40ec96414..f4154d3ab 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleWhile.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleWhile.h @@ -34,7 +34,7 @@ class CircleWhile final : public VariadicArityNode<CircleNodeImpl<CircleOpcode:: { public: CircleWhile(uint32_t arity, uint32_t out) - : VariadicArityNode<CircleNodeImpl<CircleOpcode::WHILE>>(arity), _output_count(out) + : VariadicArityNode<CircleNodeImpl<CircleOpcode::WHILE>>(arity), _output_count(out) { assert(arity > 0); assert(out > 0); diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleWhileOut.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleWhileOut.h index cdf617848..98efc21e5 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleWhileOut.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleWhileOut.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,9 +31,6 @@ namespace luci class CircleWhileOut final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::CIRCLEWHILEOUT>> { public: - CircleWhileOut() = default; - -public: loco::Node *input(void) const { return at(0)->node(); } void input(loco::Node *node) { at(0)->node(node); } diff --git a/compiler/luci/lang/include/luci/IR/Nodes/CircleZerosLike.h b/compiler/luci/lang/include/luci/IR/Nodes/CircleZerosLike.h index d3b6d272a..9302facd0 100644 --- a/compiler/luci/lang/include/luci/IR/Nodes/CircleZerosLike.h +++ b/compiler/luci/lang/include/luci/IR/Nodes/CircleZerosLike.h @@ -20,7 +20,7 @@ #include "luci/IR/CircleNodeDecl.h" #include "luci/IR/CircleOpcode.h" -#include "luci/IR/LuciNodeMixins.h" +#include "luci/IR/CircleNodeMixins.h" namespace luci { @@ -31,13 +31,7 @@ namespace luci class CircleZerosLike final : public FixedArityNode<1, CircleNodeImpl<CircleOpcode::ZEROS_LIKE>> { public: - CircleZerosLike() = default; - -public: - /// @brief Get the input node loco::Node *input(void) const { return at(0)->node(); } - - /// @brief Set the input node void input(loco::Node *node) { at(0)->node(node); } }; diff --git a/compiler/luci/lang/include/luci/IR/SparsityParam.h b/compiler/luci/lang/include/luci/IR/SparsityParam.h new file mode 100644 index 000000000..6cfff67e1 --- /dev/null +++ b/compiler/luci/lang/include/luci/IR/SparsityParam.h @@ -0,0 +1,233 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LUCI_IR_SPARSITYPARAM_H__ +#define __LUCI_IR_SPARSITYPARAM_H__ + +#include <cstdint> +#include <stdexcept> +#include <utility> +#include <vector> + +namespace luci +{ + +enum DimensionType +{ + DENSE, + SPARSE_CSR, +}; + +enum SparseIndexVectorType +{ + NONE, + I32, + U16, + U8, +}; + +class SparseIndexVector +{ +public: + SparseIndexVector() = default; + SparseIndexVector(const SparseIndexVectorType &type, const std::vector<int32_t> &sparse_index_vec) + : _type{type} + { + switch (type) + { + case SparseIndexVectorType::NONE: + break; + case SparseIndexVectorType::I32: + { + _vec_ptr = static_cast<void *>( + new std::vector<int32_t>(sparse_index_vec.begin(), sparse_index_vec.end())); + break; + } + case SparseIndexVectorType::U16: + { + auto new_vec = new std::vector<uint16_t>(sparse_index_vec.size()); + for (uint32_t idx = 0; idx < sparse_index_vec.size(); idx++) + { + new_vec->at(idx) = static_cast<uint16_t>(sparse_index_vec.at(idx)); + } + _vec_ptr = static_cast<void *>(new_vec); + break; + } + case SparseIndexVectorType::U8: + { + auto new_vec = new std::vector<uint8_t>(sparse_index_vec.size()); + for (uint32_t idx = 0; idx < sparse_index_vec.size(); idx++) + { + new_vec->at(idx) = static_cast<uint8_t>(sparse_index_vec.at(idx)); + } + _vec_ptr = static_cast<void *>(new_vec); + break; + } + default: + std::runtime_error("Invalid SparseIndexVectorType"); + } + } + + SparseIndexVector(SparseIndexVectorType type, const void *sparse_index_vec) : _type{type} + { + switch (type) + { + case SparseIndexVectorType::NONE: + break; + case SparseIndexVectorType::I32: + { + const std::vector<int32_t> *vec = + static_cast<const std::vector<int32_t> *>(sparse_index_vec); + _vec_ptr = static_cast<void *>(new std::vector<int32_t>(vec->begin(), vec->end())); + break; + } + case SparseIndexVectorType::U16: + { + const std::vector<uint16_t> *vec = + static_cast<const std::vector<uint16_t> *>(sparse_index_vec); + _vec_ptr = static_cast<void *>(new std::vector<uint16_t>(vec->begin(), vec->end())); + break; + } + case SparseIndexVectorType::U8: + { + const std::vector<uint8_t> *vec = + static_cast<const std::vector<uint8_t> *>(sparse_index_vec); + _vec_ptr = static_cast<void *>(new std::vector<uint8_t>(vec->begin(), vec->end())); + break; + } + default: + std::runtime_error("Invalid SparseIndexVectorType"); + } + } + + SparseIndexVector(const SparseIndexVector &sparse_index_vec) + : SparseIndexVector(sparse_index_vec._type, sparse_index_vec._vec_ptr) + { + } + + SparseIndexVector(SparseIndexVector &&sparse_index_vec) + : _type{sparse_index_vec._type}, _vec_ptr{std::exchange(sparse_index_vec._vec_ptr, nullptr)} + { + } + + SparseIndexVector &operator=(const SparseIndexVector &sparse_index_vec) + { + return *this = SparseIndexVector(sparse_index_vec); + } + + SparseIndexVector &operator=(SparseIndexVector &&sparse_index_vector) + { + std::swap(_vec_ptr, sparse_index_vector._vec_ptr); + std::swap(_type, sparse_index_vector._type); + return *this; + } + + ~SparseIndexVector() + { + switch (_type) + { + case SparseIndexVectorType::NONE: + break; + case SparseIndexVectorType::I32: + { + auto vec_ptr = static_cast<std::vector<int32_t> *>(_vec_ptr); + delete vec_ptr; + break; + } + case SparseIndexVectorType::U16: + { + auto vec_ptr = static_cast<std::vector<uint16_t> *>(_vec_ptr); + delete vec_ptr; + break; + } + case SparseIndexVectorType::U8: + { + auto vec_ptr = static_cast<std::vector<uint8_t> *>(_vec_ptr); + delete vec_ptr; + break; + } + default: + break; + } + _vec_ptr = nullptr; + _type = SparseIndexVectorType::NONE; + } + +public: + SparseIndexVectorType type(void) const { return _type; } + +public: + const std::vector<int32_t> *as_int32_vector(void) const + { + return _type == SparseIndexVectorType::I32 ? static_cast<const std::vector<int32_t> *>(_vec_ptr) + : nullptr; + } + const std::vector<uint16_t> *as_uint16_vector(void) const + { + return _type == SparseIndexVectorType::U16 + ? static_cast<const std::vector<uint16_t> *>(_vec_ptr) + : nullptr; + } + const std::vector<uint8_t> *as_uint8_vector(void) const + { + return _type == SparseIndexVectorType::U8 ? static_cast<const std::vector<uint8_t> *>(_vec_ptr) + : nullptr; + } + +private: + SparseIndexVectorType _type{SparseIndexVectorType::NONE}; + void *_vec_ptr{nullptr}; +}; + +class DimMetaData +{ +public: + DimMetaData() = delete; + DimMetaData(DimensionType format, int32_t dense_size) : _format{format}, _dense_size{dense_size} + { + // DO NOTHING + } + DimMetaData(DimensionType format, int32_t dense_size, const SparseIndexVector &array_segments, + const SparseIndexVector &array_indices) + : _format{format}, _dense_size{dense_size}, _array_segments{array_segments}, _array_indices{ + array_indices} + { + // DO NOTHING + } + +public: + DimensionType format(void) const { return _format; } + int32_t dense_size(void) const { return _dense_size; } + const SparseIndexVector &array_segments(void) const { return _array_segments; } + const SparseIndexVector &array_indices(void) const { return _array_indices; } + +private: + DimensionType _format{DimensionType::DENSE}; + int32_t _dense_size{0}; + SparseIndexVector _array_segments; + SparseIndexVector _array_indices; +}; + +struct SparsityParam +{ + std::vector<int32_t> traversal_order; + std::vector<int32_t> block_map; + std::vector<DimMetaData> dim_metadata; +}; + +} // namespace luci + +#endif // __LUCI_IR_SPARSITYPARAM_H__ |