Skip to content

MegEngine
MegEngine

MegEngine 天元 / MegEngine
1 年多 前同步成功

通知 410
Star 4707
Fork 583
MegEngine
MegEngine
提交 935fe781 编写于 作者: M Megvii Engine Team
浏览文件
操作

chore(megbrain): format sereg.h code 

GitOrigin-RevId: 0fe1cf6a8b52e9f9e4f53de65434c965d5d272d7
上级 55042195
展开全部 隐藏空白更改
内联 并排
Showing with 709 addition and 728 deletion
src/opr/impl/dnn/dnn.sereg.h
浏览文件 @ 935fe781
此差异已折叠。
src/opr/impl/imgproc.sereg.h
浏览文件 @ 935fe781
...@@ -9,195 +9,194 @@ ...@@ -9,195 +9,194 @@
* "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/ */
#include <type_traits> //#include <type_traits>
#include "megbrain/opr/imgproc.h" #include "megbrain/opr/imgproc.h"
#include "megbrain/serialization/sereg.h" #include "megbrain/serialization/sereg.h"
#include "megdnn/opr_param_defs.h" #include "megdnn/opr_param_defs.h"
namespace mgb { namespace mgb {
namespace serialization { namespace serialization {
//! OprMaker implementation for operators with variadic arguments //! OprMaker implementation for operators with variadic arguments
template<> template <>
struct OprMaker<opr::WarpPerspective, 0> { struct OprMaker<opr::WarpPerspective, 0> {
using Opr = opr::WarpPerspective; using Opr = opr::WarpPerspective;
using Param = Opr::Param; using Param = Opr::Param;
static cg::OperatorNodeBase* make(const Param& param, static cg::OperatorNodeBase* make(const Param& param,
const cg::VarNodeArray& inputs, const cg::VarNodeArray& inputs,
ComputingGraph& graph, ComputingGraph& graph,
const OperatorNodeConfig& config) { const OperatorNodeConfig& config) {
MGB_MARK_USED_VAR(graph); MGB_MARK_USED_VAR(graph);
if (inputs.size() == 3) { if (inputs.size() == 3) {
return Opr::make(inputs[0], inputs[1], inputs[2], param, config) return Opr::make(inputs[0], inputs[1], inputs[2], param, config)
.node() .node()
->owner_opr(); ->owner_opr();
} else { } else {
mgb_assert(inputs.size() == 4); mgb_assert(inputs.size() == 4);
return Opr::make(inputs[0], inputs[1], inputs[2], inputs[3], return Opr::make(inputs[0], inputs[1], inputs[2], inputs[3], param,
param, config) config)
.node() .node()
->owner_opr(); ->owner_opr();
}
} }
}; }
};
template <>
struct OprMaker<opr::Remap, 0> { template <>
using Opr = opr::Remap; struct OprMaker<opr::Remap, 0> {
using Param = Opr::Param; using Opr = opr::Remap;
static cg::OperatorNodeBase* make(const Param& param, using Param = Opr::Param;
const cg::VarNodeArray& inputs, static cg::OperatorNodeBase* make(const Param& param,
ComputingGraph& graph, const cg::VarNodeArray& inputs,
const OperatorNodeConfig& config) { ComputingGraph& graph,
MGB_MARK_USED_VAR(graph); const OperatorNodeConfig& config) {
if (inputs.size() == 2) { MGB_MARK_USED_VAR(graph);
return Opr::make(inputs[0], inputs[1], param, config) if (inputs.size() == 2) {
.node() return Opr::make(inputs[0], inputs[1], param, config)
->owner_opr(); .node()
} else { ->owner_opr();
return nullptr; } else {
} return nullptr;
} }
}; }
};
template<>
struct OprMaker<opr::RemapBackwardMat, 0> { template <>
using Opr = opr::RemapBackwardMat; struct OprMaker<opr::RemapBackwardMat, 0> {
using Param = Opr::Param; using Opr = opr::RemapBackwardMat;
static cg::OperatorNodeBase* make(const Param& param, using Param = Opr::Param;
const cg::VarNodeArray& inputs, static cg::OperatorNodeBase* make(const Param& param,
ComputingGraph& graph, const cg::VarNodeArray& inputs,
const OperatorNodeConfig& config) { ComputingGraph& graph,
MGB_MARK_USED_VAR(graph); const OperatorNodeConfig& config) {
if (inputs.size() == 3) { MGB_MARK_USED_VAR(graph);
return Opr::make(inputs[0], inputs[1], inputs[2], param, config) if (inputs.size() == 3) {
.node() return Opr::make(inputs[0], inputs[1], inputs[2], param, config)
->owner_opr(); .node()
} else { ->owner_opr();
return nullptr; } else {
} return nullptr;
} }
}; }
};
template<>
struct OprMaker<opr::RemapBackwardData, 0> { template <>
using Opr = opr::RemapBackwardData; struct OprMaker<opr::RemapBackwardData, 0> {
using Param = Opr::Param; using Opr = opr::RemapBackwardData;
static cg::OperatorNodeBase* make(const Param& param, using Param = Opr::Param;
const cg::VarNodeArray& inputs, static cg::OperatorNodeBase* make(const Param& param,
ComputingGraph& graph, const cg::VarNodeArray& inputs,
const OperatorNodeConfig& config) { ComputingGraph& graph,
MGB_MARK_USED_VAR(graph); const OperatorNodeConfig& config) {
if (inputs.size() == 3) { MGB_MARK_USED_VAR(graph);
return Opr::make(inputs[0], inputs[1], inputs[2], param, config) if (inputs.size() == 3) {
.node() return Opr::make(inputs[0], inputs[1], inputs[2], param, config)
->owner_opr(); .node()
} else { ->owner_opr();
return nullptr; } else {
} return nullptr;
} }
}; }
};
template <>
struct OprMaker<opr::DctChannelSelectForward, 0> { template <>
using Opr = opr::DctChannelSelectForward; struct OprMaker<opr::DctChannelSelectForward, 0> {
using Param = Opr::Param; using Opr = opr::DctChannelSelectForward;
static cg::OperatorNodeBase* make(const Param& param, using Param = Opr::Param;
const cg::VarNodeArray& inputs, static cg::OperatorNodeBase* make(const Param& param,
ComputingGraph& graph, const cg::VarNodeArray& inputs,
const OperatorNodeConfig& config) { ComputingGraph& graph,
MGB_MARK_USED_VAR(graph); const OperatorNodeConfig& config) {
if (inputs.size() == 3) { MGB_MARK_USED_VAR(graph);
return Opr::make(inputs[0], inputs[1], inputs[2], param, config) if (inputs.size() == 3) {
.node() return Opr::make(inputs[0], inputs[1], inputs[2], param, config)
->owner_opr(); .node()
} else { ->owner_opr();
mgb_assert(inputs.size() == 1); } else {
return Opr::make(inputs[0], param, config).node()->owner_opr(); mgb_assert(inputs.size() == 1);
} return Opr::make(inputs[0], param, config).node()->owner_opr();
} }
}; }
};
template<>
struct OprMaker<opr::WarpPerspectiveBackwardData, 0> { template <>
using Opr = opr::WarpPerspectiveBackwardData; struct OprMaker<opr::WarpPerspectiveBackwardData, 0> {
using Param = Opr::Param; using Opr = opr::WarpPerspectiveBackwardData;
static cg::OperatorNodeBase* make(const Param& param, using Param = Opr::Param;
const cg::VarNodeArray& inputs, static cg::OperatorNodeBase* make(const Param& param,
ComputingGraph& graph, const cg::VarNodeArray& inputs,
const OperatorNodeConfig& config) { ComputingGraph& graph,
MGB_MARK_USED_VAR(graph); const OperatorNodeConfig& config) {
if (inputs.size() == 3) { MGB_MARK_USED_VAR(graph);
return Opr::make(inputs[0], inputs[1], inputs[2], param, config) if (inputs.size() == 3) {
.node() return Opr::make(inputs[0], inputs[1], inputs[2], param, config)
->owner_opr(); .node()
} else { ->owner_opr();
mgb_assert(inputs.size() == 4); } else {
return Opr::make(inputs[0], inputs[1], inputs[2], inputs[3], mgb_assert(inputs.size() == 4);
param, config) return Opr::make(inputs[0], inputs[1], inputs[2], inputs[3], param,
.node() config)
->owner_opr(); .node()
} ->owner_opr();
} }
}; }
};
template<>
struct OprMaker<opr::WarpPerspectiveBackwardMat, 0> { template <>
using Opr = opr::WarpPerspectiveBackwardMat; struct OprMaker<opr::WarpPerspectiveBackwardMat, 0> {
using Param = Opr::Param; using Opr = opr::WarpPerspectiveBackwardMat;
static cg::OperatorNodeBase* make(const Param& param, using Param = Opr::Param;
const cg::VarNodeArray& inputs, static cg::OperatorNodeBase* make(const Param& param,
ComputingGraph& graph, const cg::VarNodeArray& inputs,
const OperatorNodeConfig& config) { ComputingGraph& graph,
MGB_MARK_USED_VAR(graph); const OperatorNodeConfig& config) {
if (inputs.size() == 3) { MGB_MARK_USED_VAR(graph);
return Opr::make(inputs[0], inputs[1], inputs[2], param, config) if (inputs.size() == 3) {
.node() return Opr::make(inputs[0], inputs[1], inputs[2], param, config)
->owner_opr(); .node()
} else { ->owner_opr();
mgb_assert(inputs.size() == 4); } else {
return Opr::make(inputs[0], inputs[1], inputs[2], inputs[3], mgb_assert(inputs.size() == 4);
param, config) return Opr::make(inputs[0], inputs[1], inputs[2], inputs[3], param,
.node() config)
->owner_opr(); .node()
} ->owner_opr();
} }
}; }
} // namespace serialization };
} // namespace serialization
namespace opr { namespace opr {
using WarpPerspectiveV2=WarpPerspective; using WarpPerspectiveV2 = WarpPerspective;
using WarpPerspectiveBackwardDataV2=WarpPerspectiveBackwardData; using WarpPerspectiveBackwardDataV2 = WarpPerspectiveBackwardData;
using WarpPerspectiveBackwardMatV2=WarpPerspectiveBackwardMat; using WarpPerspectiveBackwardMatV2 = WarpPerspectiveBackwardMat;
MGB_SEREG_OPR(WarpPerspectiveV2, 0); MGB_SEREG_OPR(WarpPerspectiveV2, 0);
MGB_SEREG_OPR(WarpPerspectiveBackwardDataV2, 0); MGB_SEREG_OPR(WarpPerspectiveBackwardDataV2, 0);
MGB_SEREG_OPR(WarpPerspectiveBackwardMatV2, 0); MGB_SEREG_OPR(WarpPerspectiveBackwardMatV2, 0);
MGB_SEREG_OPR(Rotate, 1); MGB_SEREG_OPR(Rotate, 1);
MGB_SEREG_OPR(CvtColor, 1); MGB_SEREG_OPR(CvtColor, 1);
MGB_SEREG_OPR(GaussianBlur, 1); MGB_SEREG_OPR(GaussianBlur, 1);
MGB_SEREG_OPR(ResizeBackward, 2); MGB_SEREG_OPR(ResizeBackward, 2);
using RemapV1=Remap; using RemapV1 = Remap;
using RemapBackwardDataV1=RemapBackwardData; using RemapBackwardDataV1 = RemapBackwardData;
using RemapBackwardMatV1=RemapBackwardMat; using RemapBackwardMatV1 = RemapBackwardMat;
MGB_SEREG_OPR(RemapV1, 2); MGB_SEREG_OPR(RemapV1, 2);
MGB_SEREG_OPR(RemapBackwardDataV1, 3); MGB_SEREG_OPR(RemapBackwardDataV1, 3);
MGB_SEREG_OPR(RemapBackwardMatV1, 3); MGB_SEREG_OPR(RemapBackwardMatV1, 3);
//! current warp affine version //! current warp affine version
using WarpAffineV2 = opr::WarpAffine; using WarpAffineV2 = opr::WarpAffine;
MGB_SEREG_OPR(WarpAffineV2, 3); MGB_SEREG_OPR(WarpAffineV2, 3);
//! current resize version //! current resize version
using ResizeV2 = opr::Resize; using ResizeV2 = opr::Resize;
MGB_SEREG_OPR(ResizeV2, 2); MGB_SEREG_OPR(ResizeV2, 2);
using DctChannelSelectV1 = opr::DctChannelSelect; using DctChannelSelectV1 = opr::DctChannelSelect;
MGB_SEREG_OPR(DctChannelSelectV1, 0); MGB_SEREG_OPR(DctChannelSelectV1, 0);
} // namespace opr } // namespace opr
} // namespace mgb } // namespace mgb
// vim: ft=cpp syntax=cpp.doxygen foldmethod=marker foldmarker=f{{{,f}}} // vim: ft=cpp syntax=cpp.doxygen foldmethod=marker foldmarker=f{{{,f}}}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或