diff --git a/build.sh b/build.sh index f333c25d..96c46e1a 100755 --- a/build.sh +++ b/build.sh @@ -174,12 +174,12 @@ build_graphengine() elif [ "x${PLATFORM}" = "xinference" ] then TARGET="ge_compiler atc_atc.bin ge_executor_shared ${TARGET}" + elif [ "X$ENABLE_GE_ST" = "Xon" ] + then + TARGET="ge_graph_dsl_test graph_engine_test" elif [ "X$ENABLE_GE_UT" = "Xon" ] then TARGET="ut_libgraph ut_libge_multiparts_utest ut_libge_others_utest ut_libge_kernel_utest ut_libge_distinct_load_utest" - elif [ "X$ENABLE_GE_ST" = "Xon" ] - then - TARGET="graph_engine_test" elif [ "X$MINDSPORE_MODE" = "Xon" ] then TARGET="ge_common graph" @@ -242,15 +242,17 @@ if [[ "X$ENABLE_GE_ST" = "Xon" ]]; then mkdir -p ${OUTPUT_PATH}/plugin/nnengine mkdir -p ${OUTPUT_PATH}/plugin/nnengine/ge_config mkdir -p ${OUTPUT_PATH}/plugin/opskernel - cp ${BUILD_PATH}/tests/st/libnnengine.so ${OUTPUT_PATH}/plugin/nnengine + cp ${BUILD_PATH}/tests/framework/libnnengine.so ${OUTPUT_PATH}/plugin/nnengine cp ${BUILD_PATH}/engine_conf.json ${OUTPUT_PATH}/plugin/nnengine/ge_config - cp ${BUILD_PATH}/tests/st/libhost_cpu_engine.so ${OUTPUT_PATH}/plugin/opskernel - cp ${BUILD_PATH}/tests/st/libge_local_engine.so ${OUTPUT_PATH}/plugin/opskernel - cp ${BUILD_PATH}/tests/st/framework/libfe.so ${OUTPUT_PATH}/plugin/opskernel + cp ${BUILD_PATH}/tests/framework/libhost_cpu_engine.so ${OUTPUT_PATH}/plugin/opskernel + cp ${BUILD_PATH}/tests/framework/libge_local_engine.so ${OUTPUT_PATH}/plugin/opskernel + cp ${BUILD_PATH}/tests/framework/stub_engine/libfe.so ${OUTPUT_PATH}/plugin/opskernel #prepare st execution bin cp ${BUILD_PATH}/tests/st/testcase/graph_engine_test ${OUTPUT_PATH} + cp ${BUILD_PATH}/tests/framework/ge_graph_dsl/tests/ge_graph_dsl_test ${OUTPUT_PATH} #execute st testcase RUN_TEST_CASE=${OUTPUT_PATH}/graph_engine_test && ${RUN_TEST_CASE} + RUN_TEST_CASE=${OUTPUT_PATH}/ge_graph_dsl_test && ${RUN_TEST_CASE} if [[ "$?" -ne 0 ]]; then echo "!!! ST FAILED, PLEASE CHECK YOUR CHANGES !!!" echo -e "\033[31m${RUN_TEST_CASE}\033[0m" diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index a56705e0..cfad36e1 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -28,5 +28,6 @@ if (ENABLE_GE_COV OR ENABLE_GE_UT) endif() if (ENABLE_GE_ST) + add_subdirectory(framework) add_subdirectory(st) endif() diff --git a/tests/framework/CMakeLists.txt b/tests/framework/CMakeLists.txt new file mode 100644 index 00000000..d7c806a6 --- /dev/null +++ b/tests/framework/CMakeLists.txt @@ -0,0 +1,32 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# 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. +# ============================================================================ + +include(cmake/graphengine.cmake) +add_subdirectory(easy_graph) +add_subdirectory(stub_engine) +add_subdirectory(ge_graph_dsl) + +file(GLOB_RECURSE UTILS_SRC CONFIGURE_DEPENDS + "utils/*.cc" + ) + +add_library(framework STATIC ${UTILS_SRC}) + +target_include_directories(framework + PUBLIC utils/ +) + +set_target_properties(framework PROPERTIES CXX_STANDARD 11) +target_link_libraries(framework PUBLIC ge_graph_dsl graphengine fe) diff --git a/tests/st/cmake/graphengine.cmake b/tests/framework/cmake/graphengine.cmake similarity index 100% rename from tests/st/cmake/graphengine.cmake rename to tests/framework/cmake/graphengine.cmake diff --git a/tests/framework/easy_graph/CMakeLists.txt b/tests/framework/easy_graph/CMakeLists.txt new file mode 100644 index 00000000..124cd344 --- /dev/null +++ b/tests/framework/easy_graph/CMakeLists.txt @@ -0,0 +1,26 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# 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. +# ============================================================================ + +file(GLOB_RECURSE EASY_GRAPH_SRCS src/*.cc) + +add_library(easy_graph STATIC ${EASY_GRAPH_SRCS}) + +target_link_libraries(easy_graph PUBLIC + $ ) + +set_target_properties(easy_graph PROPERTIES CXX_STANDARD 17) + +target_include_directories(easy_graph PUBLIC include + PRIVATE src) \ No newline at end of file diff --git a/tests/framework/easy_graph/include/easy_graph/builder/box_builder.h b/tests/framework/easy_graph/include/easy_graph/builder/box_builder.h new file mode 100644 index 00000000..78da155b --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/builder/box_builder.h @@ -0,0 +1,40 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HE7D53295_59F0_46B0_A881_D6A33B1F9C14 +#define HE7D53295_59F0_46B0_A881_D6A33B1F9C14 + +#include +#include "easy_graph/graph/box.h" + +EG_NS_BEGIN + +namespace detail { +template +struct BoxWrapper : Anything, Box { + using Anything::Anything; +}; + +template +using BoxedAnything = std::conditional_t, Anything, BoxWrapper>; +} // namespace detail + +#define BOX_WRAPPER(Anything) ::EG_NS::detail::BoxedAnything +#define BOX_OF(Anything, ...) ::EG_NS::BoxPacking(__VA_ARGS__) + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/builder/chain_builder.h b/tests/framework/easy_graph/include/easy_graph/builder/chain_builder.h new file mode 100644 index 00000000..7e4829d0 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/builder/chain_builder.h @@ -0,0 +1,81 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HDF50E564_F050_476A_A479_F82B20F35C84 +#define HDF50E564_F050_476A_A479_F82B20F35C84 + +#include "easy_graph/builder/link.h" +#include "easy_graph/graph/node_id.h" +#include "easy_graph/graph/node.h" + +EG_NS_BEGIN + +struct GraphBuilder; +struct Graph; +struct Edge; + +struct ChainBuilder { + ChainBuilder(GraphBuilder &graphBuilder, EdgeType defaultEdgeType); + + struct LinkBuilder { + using NodeObj = ::EG_NS::Node; + using EdgeObj = ::EG_NS::Edge; + + LinkBuilder(ChainBuilder &chain, EdgeType defaultEdgeType); + + ChainBuilder &Node(const NodeObj &node); + + template + ChainBuilder &Node(const NodeId &id, const PARAMS &... params) { + auto node = chain_.FindNode(id); + if (node) { + return this->Node(*node); + } + return this->Node(NodeObj(id, params...)); + } + + ChainBuilder &Ctrl(const std::string &label = ""); + ChainBuilder &Data(const std::string &label = ""); + + ChainBuilder &Data(PortId srcId = UNDEFINED_PORT_ID, PortId dstId = UNDEFINED_PORT_ID, + const std::string &label = ""); + + ChainBuilder &Edge(EdgeType type, PortId srcId = UNDEFINED_PORT_ID, PortId dstId = UNDEFINED_PORT_ID, + const std::string &label = ""); + + private: + ChainBuilder &startLink(const Link &); + + private: + ChainBuilder &chain_; + EdgeType default_edge_type_; + Link from_link_; + } linker; + + LinkBuilder *operator->(); + + private: + ChainBuilder &LinkTo(const Node &, const Link &); + const Node *FindNode(const NodeId &) const; + + private: + Node *prev_node_{nullptr}; + GraphBuilder &graph_builder_; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/builder/graph_builder.h b/tests/framework/easy_graph/include/easy_graph/builder/graph_builder.h new file mode 100644 index 00000000..d55ed7ca --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/builder/graph_builder.h @@ -0,0 +1,64 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H5FED5F58_167D_4536_918A_D5FE8F28DD9C +#define H5FED5F58_167D_4536_918A_D5FE8F28DD9C + +#include "easy_graph/graph/graph.h" + +EG_NS_BEGIN + +struct Link; + +struct GraphBuilder { + GraphBuilder(const std::string &name); + + Node *BuildNode(const Node &); + Edge *BuildEdge(const Node &src, const Node &dst, const Link &); + + Graph &operator*() { + return graph_; + } + + const Graph &operator*() const { + return graph_; + } + + Graph *operator->() { + return &graph_; + } + + const Graph *operator->() const { + return &graph_; + } + + private: + struct NodeInfo { + PortId inPortMax{0}; + PortId outPortMax{0}; + }; + + NodeInfo *FindNode(const NodeId &); + const NodeInfo *FindNode(const NodeId &) const; + + private: + std::map nodes_; + Graph graph_; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/builder/graph_dsl.h b/tests/framework/easy_graph/include/easy_graph/builder/graph_dsl.h new file mode 100644 index 00000000..4d430983 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/builder/graph_dsl.h @@ -0,0 +1,45 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H46D07001_D54E_497C_B1BA_878A47164DA5 +#define H46D07001_D54E_497C_B1BA_878A47164DA5 + +#include "easy_graph/builder/graph_builder.h" +#include "easy_graph/builder/chain_builder.h" +#include "easy_graph/builder/box_builder.h" +#include "easy_graph/infra/macro_traits.h" + +EG_NS_BEGIN + +//////////////////////////////////////////////////////////////// +namespace detail { +template +Graph BuildGraph(const char *name, GRAPH_BUILDER builderInDSL) { + GraphBuilder builder(name); + builderInDSL(builder); + return std::move(*builder); +} +} // namespace detail + +#define HAS_NAME(...) NOT_EMPTY_SELECT(__VA_ARGS__) +#define DEF_GRAPH(G, ...) ::EG_NS::Graph G = ::EG_NS::detail::BuildGraph(HAS_NAME(__VA_ARGS__)(__VA_ARGS__, #G), [&](::EG_NS::GraphBuilder& BUILDER) +#define DATA_CHAIN(...) ::EG_NS::ChainBuilder(BUILDER, ::EG_NS::EdgeType::DATA)->__VA_ARGS__ +#define CTRL_CHAIN(...) ::EG_NS::ChainBuilder(BUILDER, ::EG_NS::EdgeType::CTRL)->__VA_ARGS__ +#define CHAIN(...) DATA_CHAIN(__VA_ARGS__) + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/builder/link.h b/tests/framework/easy_graph/include/easy_graph/builder/link.h new file mode 100644 index 00000000..83c6de69 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/builder/link.h @@ -0,0 +1,49 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H35695B82_E9E5_419D_A6B4_C13FB0842C9F +#define H35695B82_E9E5_419D_A6B4_C13FB0842C9F + +#include +#include "easy_graph/graph/edge_type.h" +#include "easy_graph/graph/port_id.h" + +EG_NS_BEGIN + +struct Link { + explicit Link(EdgeType type) : type_(type) { + Reset(type); + } + + Link(EdgeType type, const std::string &label, PortId srcPortId, PortId dstPortId) + : type_(type), label_(label), src_port_id_(srcPortId), dst_port_id_(dstPortId) {} + + void Reset(EdgeType type) { + this->type_ = type; + this->label_ = ""; + this->src_port_id_ = UNDEFINED_PORT_ID; + this->dst_port_id_ = UNDEFINED_PORT_ID; + } + + EdgeType type_; + std::string label_; + PortId src_port_id_; + PortId dst_port_id_; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/eg.h b/tests/framework/easy_graph/include/easy_graph/eg.h new file mode 100644 index 00000000..ac96daf8 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/eg.h @@ -0,0 +1,29 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H04F67145_86B2_4529_BC2E_EBDB2115687E +#define H04F67145_86B2_4529_BC2E_EBDB2115687E + +#define EG_NS eg +#define EG_NS_BEGIN namespace EG_NS { +#define EG_NS_END } +#define USING_EG_NS using namespace EG_NS; +#define FWD_DECL_EG(type) \ + namespace EG_NS { \ + struct type; \ + } + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/graph/box.h b/tests/framework/easy_graph/include/easy_graph/graph/box.h new file mode 100644 index 00000000..cdb55960 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/graph/box.h @@ -0,0 +1,41 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H4AA49861_3311_4114_8687_1C7D04FA43B9 +#define H4AA49861_3311_4114_8687_1C7D04FA43B9 + +#include +#include "easy_graph/infra/keywords.h" + +EG_NS_BEGIN + +INTERFACE(Box){}; + +using BoxPtr = std::shared_ptr; + +template +BoxPtr BoxPacking(Args &&... args) { + return std::make_shared(std::forward(args)...); +} + +template +Anything *BoxUnpacking(const BoxPtr &box) { + return dynamic_cast(box.get()); +} + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/graph/edge.h b/tests/framework/easy_graph/include/easy_graph/graph/edge.h new file mode 100644 index 00000000..f4066b8b --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/graph/edge.h @@ -0,0 +1,46 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HE62943BF_1F7C_4EF9_B306_D9C94634EA74 +#define HE62943BF_1F7C_4EF9_B306_D9C94634EA74 + +#include +#include "easy_graph/graph/edge_type.h" +#include "easy_graph/graph/endpoint.h" + +EG_NS_BEGIN + +struct Edge { + Edge(const EdgeType type, const std::string &label, const Endpoint &src, const Endpoint &dst); + + __DECL_COMP(Edge); + + EdgeType GetType() const; + std::string GetLabel() const; + + Endpoint GetSrc() const; + Endpoint GetDst() const; + + private: + std::string label_; + EdgeType type_; + Endpoint src_; + Endpoint dst_; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/graph/edge_type.h b/tests/framework/easy_graph/include/easy_graph/graph/edge_type.h new file mode 100644 index 00000000..f7c482c0 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/graph/edge_type.h @@ -0,0 +1,31 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H19D3F004_119F_4E6A_ACFA_A635FD6FEA98 +#define H19D3F004_119F_4E6A_ACFA_A635FD6FEA98 + +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +enum class EdgeType { + CTRL = 0, + DATA, +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/graph/endpoint.h b/tests/framework/easy_graph/include/easy_graph/graph/endpoint.h new file mode 100644 index 00000000..a595b039 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/graph/endpoint.h @@ -0,0 +1,41 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H8DB48A37_3257_4E15_8869_09E58221ADE8 +#define H8DB48A37_3257_4E15_8869_09E58221ADE8 + +#include "easy_graph/graph/node_id.h" +#include "easy_graph/graph/port_id.h" +#include "easy_graph/infra/operator.h" + +EG_NS_BEGIN + +struct Endpoint { + Endpoint(const NodeId &, const PortId &); + + __DECL_COMP(Endpoint); + + NodeId getNodeId() const; + PortId getPortId() const; + + private: + NodeId node_id_; + PortId port_id_; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/graph/graph.h b/tests/framework/easy_graph/include/easy_graph/graph/graph.h new file mode 100644 index 00000000..f967b649 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/graph/graph.h @@ -0,0 +1,58 @@ +#ifndef H813EC8C1_3850_4320_8AC0_CE071C89B871 +#define H813EC8C1_3850_4320_8AC0_CE071C89B871 + +#include "easy_graph/graph/node.h" +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/graph/edge.h" +#include "easy_graph/infra/status.h" +#include +#include +#include + +EG_NS_BEGIN + +struct GraphVisitor; +struct LayoutOption; + +struct Graph { + explicit Graph(const std::string &name); + + std::string GetName() const; + + Node *AddNode(const Node &); + Edge *AddEdge(const Edge &); + + Node *FindNode(const NodeId &); + const Node *FindNode(const NodeId &) const; + + std::pair FindNodePair(const Edge &) const; + std::pair FindNodePair(const Edge &); + + void Accept(GraphVisitor &) const; + + Status Layout(const LayoutOption *option = nullptr) const; + + private: + std::string name_; + std::map nodes_; + std::set edges_; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/graph/graph_visitor.h b/tests/framework/easy_graph/include/easy_graph/graph/graph_visitor.h new file mode 100644 index 00000000..4d4ad408 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/graph/graph_visitor.h @@ -0,0 +1,37 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H13960AED_B5B1_45F9_A664_6CB6C15CA3C1 +#define H13960AED_B5B1_45F9_A664_6CB6C15CA3C1 + +#include "easy_graph/infra/keywords.h" +#include "easy_graph/infra/status.h" + +EG_NS_BEGIN + +struct Graph; +struct Node; +struct Edge; + +INTERFACE(GraphVisitor) { + DEFAULT(Status, Visit(const Graph &)); + DEFAULT(Status, Visit(const Node &)); + DEFAULT(Status, Visit(const Edge &)); +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/graph/node.h b/tests/framework/easy_graph/include/easy_graph/graph/node.h new file mode 100644 index 00000000..5f7f46e1 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/graph/node.h @@ -0,0 +1,62 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HF37ACE88_F726_4AA3_8599_ED7A888AA623 +#define HF37ACE88_F726_4AA3_8599_ED7A888AA623 + +#include +#include "easy_graph/graph/node_id.h" +#include "easy_graph/infra/operator.h" +#include "easy_graph/infra/ext_traits.h" +#include "easy_graph/graph/box.h" + +EG_NS_BEGIN + +struct GraphVisitor; +struct Graph; + +struct Node { + template + Node(const NodeId &id, const GRAPHS &... graphs) : id_(id), subgraphs_{&graphs...} {} + + template + Node(const NodeId &id, const BoxPtr &box, const GRAPHS &... graphs) : id_(id), box_(box), subgraphs_{&graphs...} {} + + __DECL_COMP(Node); + + NodeId GetId() const; + + Node &Packing(const BoxPtr &); + + template + Anything *Unpacking() const { + if (!box_) + return nullptr; + return BoxUnpacking(box_); + } + + Node &AddSubgraph(const Graph &); + void Accept(GraphVisitor &) const; + + private: + NodeId id_; + BoxPtr box_; + std::vector subgraphs_; +}; + +EG_NS_END + +#endif diff --git a/tests/st/framework/framework.h b/tests/framework/easy_graph/include/easy_graph/graph/node_id.h similarity index 76% rename from tests/st/framework/framework.h rename to tests/framework/easy_graph/include/easy_graph/graph/node_id.h index 4a2c5575..8c98e8da 100644 --- a/tests/st/framework/framework.h +++ b/tests/framework/easy_graph/include/easy_graph/graph/node_id.h @@ -1,22 +1,29 @@ /** * Copyright 2021 Huawei Technologies Co., Ltd - + * * 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 HB53D0830_615F_4E4A_8531_77E2A177717D +#define HB53D0830_615F_4E4A_8531_77E2A177717D -#ifndef GRAPHENGINE_LLT_ST_FRAMEWORK_H_ -#define GRAPHENGINE_LLT_ST_FRAMEWORK_H_ #include -#include "common/ge_inner_error_codes.h" +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +typedef std::string NodeId; + +EG_NS_END -#endif // GRAPHENGINE_LLT_ST_FRAMEWORK_H_ +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/graph/port_id.h b/tests/framework/easy_graph/include/easy_graph/graph/port_id.h new file mode 100644 index 00000000..4c82cfae --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/graph/port_id.h @@ -0,0 +1,30 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HC8732748_F658_4759_9284_CC13C0BFE6D4 +#define HC8732748_F658_4759_9284_CC13C0BFE6D4 + +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +typedef unsigned int PortId; + +static const PortId UNDEFINED_PORT_ID = 0xFFFFFFFF; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/infra/default.h b/tests/framework/easy_graph/include/easy_graph/infra/default.h new file mode 100644 index 00000000..124cb89b --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/infra/default.h @@ -0,0 +1,59 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H05B2224D_B926_4FC0_A936_77B52B8A98DB +#define H05B2224D_B926_4FC0_A936_77B52B8A98DB + +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +namespace details { +template +struct DefaultValue { + static T value() { + return T(); + } +}; + +template +struct DefaultValue { + static T *value() { + return 0; + } +}; + +template +struct DefaultValue { + static T *value() { + return 0; + } +}; + +template<> +struct DefaultValue { + static void value() {} +}; +} // namespace details + +#define DEFAULT(type, method) \ + virtual type method { \ + return ::EG_NS::details::DefaultValue::value(); \ + } + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/infra/ext_traits.h b/tests/framework/easy_graph/include/easy_graph/infra/ext_traits.h new file mode 100644 index 00000000..6f637658 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/infra/ext_traits.h @@ -0,0 +1,39 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HF25A2E8D_A775_44BF_88D1_166DFF56186A +#define HF25A2E8D_A775_44BF_88D1_166DFF56186A + +#include +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +template +using all_same_traits = typename std::enable_if...>::value>::type; + +template +using all_same_but_none_traits = typename std::enable_if< + std::disjunction, std::conjunction...>>::value>::type; + +#define ALL_SAME_CONCEPT(TS, T) all_same_traits * = nullptr +#define ALL_SAME_BUT_NONE_CONCEPT(TS, T) ::EG_NS::all_same_but_none_traits * = nullptr + +#define SUBGRAPH_CONCEPT(GS, G) ALL_SAME_BUT_NONE_CONCEPT(GS, G) + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/infra/keywords.h b/tests/framework/easy_graph/include/easy_graph/infra/keywords.h new file mode 100644 index 00000000..6adf9a14 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/infra/keywords.h @@ -0,0 +1,42 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H05B2224D_B926_4FC0_A936_97B52B8A98DB +#define H05B2224D_B926_4FC0_A936_97B52B8A98DB + +#include "easy_graph/infra/default.h" + +EG_NS_BEGIN + +namespace details { +template +struct Interface { + virtual ~Interface() {} +}; +} // namespace details + +#define INTERFACE(Intf) struct Intf : ::EG_NS::details::Interface + +#define ABSTRACT(...) virtual __VA_ARGS__ = 0 + +#define OVERRIDE(...) virtual __VA_ARGS__ override + +#define EXTENDS(...) , ##__VA_ARGS__ +#define IMPLEMENTS(...) EXTENDS(__VA_ARGS__) + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/infra/log.h b/tests/framework/easy_graph/include/easy_graph/infra/log.h new file mode 100644 index 00000000..0ff269d9 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/infra/log.h @@ -0,0 +1,64 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H38247538_297F_4A80_94D3_8A289788461B +#define H38247538_297F_4A80_94D3_8A289788461B + +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +enum EgLogLevel { + EG_NONE_LEVEL = 0x0, + EG_DEBUG_LEVEL = 0x01, + EG_INFO_LEVEL = 0x02, + EG_SUCC_LEVEL = 0x04, + EG_WARN_LEVEL = 0x08, + EG_ERR_LEVEL = 0x10, + EG_FATAL_LEVEL = 0x20, + EG_TOTAL_LEVEL = 0xFF +}; + +#define EG_LOG_LEVELS (EG_FATAL_LEVEL | EG_ERR_LEVEL | EG_WARN_LEVEL | EG_INFO_LEVEL) + +///////////////////////////////////////////////////////////////// + +void eg_log(int level, const char *levelstr, const char *file, unsigned int line, const char *fmt, ...); + +#define EG_LOG_OUTPUT eg_log + +#define __EG_LOG_TITLE(level, levelstr, fmt, ...) \ + do { \ + if (level & EG_LOG_LEVELS) { \ + EG_LOG_OUTPUT(level, levelstr, __FILE__, __LINE__, fmt, ##__VA_ARGS__); \ + } \ + } while (0) + +#define EG_FATAL(fmt, ...) __EG_LOG_TITLE(EG_FATAL_LEVEL, "FATAL", fmt, ##__VA_ARGS__) + +#define EG_ERR(fmt, ...) __EG_LOG_TITLE(EG_ERR_LEVEL, "ERROR", fmt, ##__VA_ARGS__) + +#define EG_WARN(fmt, ...) __EG_LOG_TITLE(EG_WARN_LEVEL, "WARN", fmt, ##__VA_ARGS__) + +#define EG_SUCC(fmt, ...) __EG_LOG_TITLE(EG_SUCC_LEVEL, "SUCC", fmt, ##__VA_ARGS__) + +#define EG_INFO(fmt, ...) __EG_LOG_TITLE(EG_INFO_LEVEL, "INFO", fmt, ##__VA_ARGS__) + +#define EG_DBG(fmt, ...) __EG_LOG_TITLE(EG_DEBUG_LEVEL, "DEBUG", fmt, ##__VA_ARGS__) + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/infra/macro_traits.h b/tests/framework/easy_graph/include/easy_graph/infra/macro_traits.h new file mode 100644 index 00000000..f8ef2495 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/infra/macro_traits.h @@ -0,0 +1,58 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H7DA4A075_246A_4DD6_B1BB_ECA3806C9483 +#define H7DA4A075_246A_4DD6_B1BB_ECA3806C9483 + +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +//////////////////////////////////////////////////////////////////////// + +#define VA_ARGS_NUM(...) \ + VA_ARGS_NUM_PRIVATE(0, ##__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, \ + 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, \ + 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + +#define VA_ARGS_NUM_PRIVATE(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, \ + _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, \ + _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, \ + _56, _57, _58, _59, _60, _61, _62, _63, _64, N, ...) \ + N + +//////////////////////////////////////////////////////////////////////// + +#define __MACRO_CONCAT(x, y) x##y +#define MACRO_CONCAT(x, y) __MACRO_CONCAT(x, y) + +#define __MACRO_SECOND(FIRST, SECOND, ...) SECOND +#define MACRO_SECOND(...) __MACRO_SECOND(__VA_ARGS__) + +#define MACRO_VERIFY_FIRST(...) MACRO_SECOND(__VA_ARGS__, 1) + +#define MACRO_BOOL_0 MACRO_DUMMY, 0 +#define MACRO_BOOL(N) MACRO_VERIFY_FIRST(__MACRO_CONCAT(MACRO_BOOL_, N)) + +#define MACRO_CONDITION_0(TRUE_BRANCH, FALSE_BRANCH) FALSE_BRANCH +#define MACRO_CONDITION_1(TRUE_BRANCH, FALSE_BRANCH) TRUE_BRANCH +#define MACRO_CONDITION(N) MACRO_CONCAT(MACRO_CONDITION_, MACRO_BOOL(N)) + +#define NOT_EMPTY_SELECT(...) MACRO_CONDITION(VA_ARGS_NUM(__VA_ARGS__)) + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/infra/operator.h b/tests/framework/easy_graph/include/easy_graph/infra/operator.h new file mode 100644 index 00000000..41d794ff --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/infra/operator.h @@ -0,0 +1,68 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H05B2224D_B927_4FC0_A936_97B52B8A99DB +#define H05B2224D_B927_4FC0_A936_97B52B8A99DB + +////////////////////////////////////////////////////////////// +#define __DECL_EQUALS(cls) \ + bool operator!=(const cls &rhs) const; \ + bool operator==(const cls &rhs) const + +////////////////////////////////////////////////////////////// +#define __FIELD_EQ(name) this->name == rhs.name +#define __FIELD_LT(name) this->name < rhs.name + +////////////////////////////////////////////////////////////// +#define __SUPER_EQ(super) static_cast(*this) == rhs +#define __SUPER_LT(super) static_cast(*this) < rhs + +////////////////////////////////////////////////////////////// +#define __DEF_EQUALS(cls) \ + bool cls::operator!=(const cls &rhs) const { \ + return !(*this == rhs); \ + } \ + bool cls::operator==(const cls &rhs) const + +///////////////////////////////////////////////////////////// +#define __INLINE_EQUALS(cls) \ + bool operator!=(const cls &rhs) const { \ + return !(*this == rhs); \ + } \ + bool operator==(const cls &rhs) const + +///////////////////////////////////////////////////////////// +#define __DECL_COMP(cls) \ + __DECL_EQUALS(cls); \ + bool operator<(const cls &) const; \ + bool operator>(const cls &) const; \ + bool operator<=(const cls &) const; \ + bool operator>=(const cls &) const + +///////////////////////////////////////////////////////////// +#define __DEF_COMP(cls) \ + bool cls::operator>(const cls &rhs) const { \ + return !(*this <= rhs); \ + } \ + bool cls::operator>=(const cls &rhs) const { \ + return !(*this < rhs); \ + } \ + bool cls::operator<=(const cls &rhs) const { \ + return (*this < rhs) || (*this == rhs); \ + } \ + bool cls::operator<(const cls &rhs) const + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/infra/scope_guard.h b/tests/framework/easy_graph/include/easy_graph/infra/scope_guard.h new file mode 100644 index 00000000..4d4068fc --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/infra/scope_guard.h @@ -0,0 +1,41 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H187A4A00_BD91_4B9D_8DD9_3D6C9EA15854 +#define H187A4A00_BD91_4B9D_8DD9_3D6C9EA15854 + +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +template +struct ScopeGuard { + ScopeGuard(BEGIN begin, END end) : begin(begin), end(end) { + begin(); + } + + ~ScopeGuard() { + end(); + } + + private: + BEGIN begin; + END end; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/infra/singleton.h b/tests/framework/easy_graph/include/easy_graph/infra/singleton.h new file mode 100644 index 00000000..72fa3b66 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/infra/singleton.h @@ -0,0 +1,42 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HD18A3E42_2801_4BEB_B365_03633D1D81C4 +#define HD18A3E42_2801_4BEB_B365_03633D1D81C4 + +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +template +struct Singleton { + static T &GetInstance() { + static T instance; + return instance; + } + + Singleton(const Singleton &) = delete; + Singleton &operator=(const Singleton &) = delete; + + protected: + Singleton() {} +}; + +#define SINGLETON(object) struct object : ::EG_NS::Singleton + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/infra/status.h b/tests/framework/easy_graph/include/easy_graph/infra/status.h new file mode 100644 index 00000000..3cef8c8a --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/infra/status.h @@ -0,0 +1,55 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HA25033D6_1564_4748_B2C8_4DE2C5A286DE +#define HA25033D6_1564_4748_B2C8_4DE2C5A286DE + +#include +#include +#include "easy_graph/eg.h" + +EG_NS_BEGIN + +typedef uint32_t Status; + +#define EG_SUCC_STATUS(status) (EG_NS::Status) status +#define EG_FAIL_STATUS(status) (EG_NS::Status)(status | EG_RESERVED_FAIL) + +/* OK */ +#define EG_SUCCESS EG_SUCC_STATUS(0) + +/* Error Status */ +#define EG_RESERVED_FAIL (EG_NS::Status) 0x80000000 +#define EG_FAILURE EG_FAIL_STATUS(1) +#define EG_FATAL_BUG EG_FAIL_STATUS(2) +#define EG_TIMEDOUT EG_FAIL_STATUS(3) +#define EG_OUT_OF_RANGE EG_FAIL_STATUS(4) +#define EG_UNIMPLEMENTED EG_FAIL_STATUS(5) + +static inline bool eg_status_is_ok(Status status) { + return (status & EG_RESERVED_FAIL) == 0; +} + +static inline bool eg_status_is_fail(Status status) { + return !eg_status_is_ok(status); +} + +#define __EG_FAILED(result) eg_status_is_fail(result) +#define __EG_OK(result) eg_status_is_ok(result) + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_executor.h b/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_executor.h new file mode 100644 index 00000000..43836f66 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_executor.h @@ -0,0 +1,31 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HAC96EB3A_2169_4BB0_A8EB_7B966C262B2F +#define HAC96EB3A_2169_4BB0_A8EB_7B966C262B2F + +#include "easy_graph/layout/layout_executor.h" + +EG_NS_BEGIN + +struct GraphEasyExecutor : LayoutExecutor { + private: + Status Layout(const Graph &, const LayoutOption *) override; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_layout_context.h b/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_layout_context.h new file mode 100644 index 00000000..b9fc8e46 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_layout_context.h @@ -0,0 +1,53 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HB8CC77BE_6A2E_4EB4_BE59_CA85DE56C027 +#define HB8CC77BE_6A2E_4EB4_BE59_CA85DE56C027 + +#include "easy_graph/eg.h" +#include +#include + +EG_NS_BEGIN + +struct GraphEasyOption; +struct Graph; + +struct GraphEasyLayoutContext { + GraphEasyLayoutContext(const GraphEasyOption &); + + const Graph *GetCurrentGraph() const; + + void EnterGraph(const Graph &); + void ExitGraph(); + + void LinkBegin(); + void LinkEnd(); + + bool InLinking() const; + + std::string GetGroupPath() const; + const GraphEasyOption &GetOptions() const; + + private: + std::deque graphs_; + const GraphEasyOption &options_; + bool is_linking_{false}; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_option.h b/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_option.h new file mode 100644 index 00000000..33690ae8 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_option.h @@ -0,0 +1,63 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H37156CC2_92BD_44DA_8DA7_A11629E762BE +#define H37156CC2_92BD_44DA_8DA7_A11629E762BE + +#include "easy_graph/layout/layout_option.h" +#include + +EG_NS_BEGIN + +enum class FlowDir { + LR = 0, + TB, +}; + +enum class LayoutType { + FREE = 0, + REGULAR, +}; + +enum class LayoutFormat { + ASCII = 0, + BOXART, + SVG, + DOT, + HTML, +}; + +enum class LayoutOutput { + CONSOLE = 0, + FILE, +}; + +struct GraphEasyOption : LayoutOption { + static const GraphEasyOption &GetDefault(); + + std::string GetLayoutCmdArgs(const std::string &graphName) const; + + LayoutFormat format_{LayoutFormat::BOXART}; + LayoutOutput output_{LayoutOutput::CONSOLE}; + FlowDir dir_{FlowDir::LR}; + LayoutType type_{LayoutType::FREE}; + size_t scale_{1}; + std::string output_path_{"./"}; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_visitor.h b/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_visitor.h new file mode 100644 index 00000000..56a6211f --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/layout/engines/graph_easy/graph_easy_visitor.h @@ -0,0 +1,45 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HB6783151_C24E_4DA3_B969_46C2298FF43F +#define HB6783151_C24E_4DA3_B969_46C2298FF43F + +#include +#include "easy_graph/graph/graph_visitor.h" +#include "easy_graph/layout/engines/graph_easy/graph_easy_layout_context.h" + +EG_NS_BEGIN + +struct GraphEasyOption; + +struct GraphEasyVisitor : GraphVisitor { + GraphEasyVisitor(const GraphEasyOption &); + + std::string GetLayout() const; + + private: + Status Visit(const Graph &) override; + Status Visit(const Node &) override; + Status Visit(const Edge &) override; + + private: + std::string layout_; + GraphEasyLayoutContext ctxt_; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/layout/graph_layout.h b/tests/framework/easy_graph/include/easy_graph/layout/graph_layout.h new file mode 100644 index 00000000..bd0c71af --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/layout/graph_layout.h @@ -0,0 +1,40 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H550E4ACB_BEC7_4E71_8C6F_CD7FA53662A9 +#define H550E4ACB_BEC7_4E71_8C6F_CD7FA53662A9 + +#include "easy_graph/infra/status.h" +#include "easy_graph/infra/singleton.h" + +EG_NS_BEGIN + +struct LayoutExecutor; +struct LayoutOption; +struct Graph; + +SINGLETON(GraphLayout) { + void Config(LayoutExecutor &, const LayoutOption * = nullptr); + Status Layout(const Graph &, const LayoutOption * = nullptr); + + private: + LayoutExecutor *executor_{nullptr}; + const LayoutOption *options_{nullptr}; +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/layout/layout_executor.h b/tests/framework/easy_graph/include/easy_graph/layout/layout_executor.h new file mode 100644 index 00000000..089b5463 --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/layout/layout_executor.h @@ -0,0 +1,34 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HE4984335_C586_4533_A056_27F9F996DF50 +#define HE4984335_C586_4533_A056_27F9F996DF50 + +#include "easy_graph/infra/status.h" +#include "easy_graph/infra/keywords.h" + +EG_NS_BEGIN + +struct Graph; +struct LayoutOption; + +INTERFACE(LayoutExecutor) { + ABSTRACT(Status Layout(const Graph &, const LayoutOption *)); +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/include/easy_graph/layout/layout_option.h b/tests/framework/easy_graph/include/easy_graph/layout/layout_option.h new file mode 100644 index 00000000..fd732a7e --- /dev/null +++ b/tests/framework/easy_graph/include/easy_graph/layout/layout_option.h @@ -0,0 +1,28 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H9491820D_4371_4C88_804E_4C77613F80C1 +#define H9491820D_4371_4C88_804E_4C77613F80C1 + +#include "easy_graph/infra/keywords.h" + +EG_NS_BEGIN + +INTERFACE(LayoutOption){}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/src/builder/chain_builder.cc b/tests/framework/easy_graph/src/builder/chain_builder.cc new file mode 100644 index 00000000..0e48f2b3 --- /dev/null +++ b/tests/framework/easy_graph/src/builder/chain_builder.cc @@ -0,0 +1,72 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/builder/chain_builder.h" +#include "easy_graph/builder/graph_builder.h" + +EG_NS_BEGIN + +ChainBuilder::ChainBuilder(GraphBuilder &graphBuilder, EdgeType defaultEdgeType) + : linker(*this, defaultEdgeType), graph_builder_(graphBuilder) {} + +ChainBuilder::LinkBuilder *ChainBuilder::operator->() { + return &linker; +} + +ChainBuilder &ChainBuilder::LinkTo(const Node &node, const Link &link) { + Node *currentNode = graph_builder_.BuildNode(node); + if (prev_node_) { + graph_builder_.BuildEdge(*prev_node_, *currentNode, link); + } + prev_node_ = currentNode; + return *this; +} + +const Node *ChainBuilder::FindNode(const NodeId &id) const { + return graph_builder_->FindNode(id); +} + +ChainBuilder::LinkBuilder::LinkBuilder(ChainBuilder &chain, EdgeType defaultEdgeType) + : chain_(chain), default_edge_type_(defaultEdgeType), from_link_(defaultEdgeType) {} + +ChainBuilder &ChainBuilder::LinkBuilder::Node(const NodeObj &node) { + chain_.LinkTo(node, from_link_); + from_link_.Reset(default_edge_type_); + return chain_; +} + +ChainBuilder &ChainBuilder::LinkBuilder::startLink(const Link &link) { + this->from_link_ = link; + return chain_; +} + +ChainBuilder &ChainBuilder::LinkBuilder::Ctrl(const std::string &label) { + return this->Edge(EdgeType::CTRL, UNDEFINED_PORT_ID, UNDEFINED_PORT_ID, label); +} + +ChainBuilder &ChainBuilder::LinkBuilder::Data(const std::string &label) { + return this->Edge(EdgeType::DATA, UNDEFINED_PORT_ID, UNDEFINED_PORT_ID, label); +} + +ChainBuilder &ChainBuilder::LinkBuilder::Data(PortId srcId, PortId dstId, const std::string &label) { + return this->Edge(EdgeType::DATA, srcId, dstId, label); +} + +ChainBuilder &ChainBuilder::LinkBuilder::Edge(EdgeType type, PortId srcPort, PortId dstPort, const std::string &label) { + return this->startLink(Link(type, label, srcPort, dstPort)); +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/builder/graph_builder.cc b/tests/framework/easy_graph/src/builder/graph_builder.cc new file mode 100644 index 00000000..7b8e27ee --- /dev/null +++ b/tests/framework/easy_graph/src/builder/graph_builder.cc @@ -0,0 +1,78 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/builder/graph_builder.h" +#include "easy_graph/graph/endpoint.h" +#include "easy_graph/builder/link.h" +#include "easy_graph/infra/log.h" + +EG_NS_BEGIN + +namespace { +PortId getPortIdBy(const EdgeType &type, const PortId &specifiedPortId, PortId &reservedPortId) { + if (type == EdgeType::CTRL) + return 0; + if (specifiedPortId == UNDEFINED_PORT_ID) + return reservedPortId++; + if (specifiedPortId < reservedPortId) + return specifiedPortId; + reservedPortId = specifiedPortId; + return reservedPortId++; +} +} // namespace + +GraphBuilder::GraphBuilder(const std::string &name) : graph_(name) {} + +GraphBuilder::NodeInfo *GraphBuilder::FindNode(const NodeId &id) { + auto it = nodes_.find(id); + if (it == nodes_.end()) { + return nullptr; + } + return &(it->second); +} + +const GraphBuilder::NodeInfo *GraphBuilder::FindNode(const NodeId &id) const { + return const_cast(*this).FindNode(id); +} + +Node *GraphBuilder::BuildNode(const Node &node) { + auto it = nodes_.find(node.GetId()); + if (it == nodes_.end()) { + nodes_.emplace(std::make_pair(node.GetId(), NodeInfo())); + } + return graph_.AddNode(node); +} + +Edge *GraphBuilder::BuildEdge(const Node &src, const Node &dst, const Link &link) { + NodeInfo *srcInfo = FindNode(src.GetId()); + NodeInfo *dstInfo = FindNode(dst.GetId()); + + if (!srcInfo || !dstInfo) { + EG_ERR("link edge{%d : %s} error!", link.type_, link.label_.c_str()); + return nullptr; + } + + PortId srcPortId = getPortIdBy(link.type_, link.src_port_id_, srcInfo->outPortMax); + PortId dstPortId = getPortIdBy(link.type_, link.dst_port_id_, dstInfo->inPortMax); + + EG_DBG("link edge(%d) from (%s:%d) to (%s:%d)", link.type_, src.GetId().c_str(), srcPortId, dst.GetId().c_str(), + dstPortId); + + return graph_.AddEdge( + Edge(link.type_, link.label_, Endpoint(src.GetId(), srcPortId), Endpoint(dst.GetId(), dstPortId))); +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/graph/edge.cc b/tests/framework/easy_graph/src/graph/edge.cc new file mode 100644 index 00000000..65a97017 --- /dev/null +++ b/tests/framework/easy_graph/src/graph/edge.cc @@ -0,0 +1,53 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/graph/edge.h" + +EG_NS_BEGIN + +Edge::Edge(const EdgeType type, const std::string &label, const Endpoint &src, const Endpoint &dst) + : type_(type), label_(label), src_(src), dst_(dst) {} + +__DEF_EQUALS(Edge) { + return (type_ == rhs.type_) && (src_ == rhs.src_) && (dst_ == rhs.dst_); +} + +__DEF_COMP(Edge) { + if (src_ < rhs.src_) + return true; + if ((src_ == rhs.src_) && (dst_ < rhs.dst_)) + return true; + if ((src_ == rhs.src_) && (dst_ < rhs.dst_) && (type_ < rhs.type_)) + return true; + return false; +} + +EdgeType Edge::GetType() const { + return type_; +} + +std::string Edge::GetLabel() const { + return label_; +} + +Endpoint Edge::GetSrc() const { + return src_; +} +Endpoint Edge::GetDst() const { + return dst_; +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/graph/endpoint.cc b/tests/framework/easy_graph/src/graph/endpoint.cc new file mode 100644 index 00000000..995f7eac --- /dev/null +++ b/tests/framework/easy_graph/src/graph/endpoint.cc @@ -0,0 +1,43 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/graph/endpoint.h" + +EG_NS_BEGIN + +Endpoint::Endpoint(const NodeId &nodeId, const PortId &portId) : node_id_(nodeId), port_id_(portId) {} + +__DEF_EQUALS(Endpoint) { + return (node_id_ == rhs.node_id_) && (port_id_ == rhs.port_id_); +} + +__DEF_COMP(Endpoint) { + if (node_id_ < rhs.node_id_) + return true; + if ((node_id_ == rhs.node_id_) && (port_id_ < rhs.port_id_)) + return true; + return false; +} + +NodeId Endpoint::getNodeId() const { + return node_id_; +} + +PortId Endpoint::getPortId() const { + return port_id_; +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/graph/graph.cc b/tests/framework/easy_graph/src/graph/graph.cc new file mode 100644 index 00000000..a17935be --- /dev/null +++ b/tests/framework/easy_graph/src/graph/graph.cc @@ -0,0 +1,70 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/graph/graph.h" +#include "easy_graph/graph/graph_visitor.h" +#include "easy_graph/layout/graph_layout.h" +#include + +EG_NS_BEGIN + +Graph::Graph(const std::string &name) : name_(name) {} + +std::string Graph::GetName() const { + return name_; +} + +Node *Graph::AddNode(const Node &node) { + auto result = nodes_.emplace(node.GetId(), node); + return &(result.first->second); +} + +Edge *Graph::AddEdge(const Edge &edge) { + auto result = edges_.emplace(edge); + return &(const_cast(*(result.first))); +} + +Node *Graph::FindNode(const NodeId &id) { + auto it = nodes_.find(id); + if (it == nodes_.end()) { + return nullptr; + } + return &(it->second); +} + +const Node *Graph::FindNode(const NodeId &id) const { + return const_cast(*this).FindNode(id); +} + +std::pair Graph::FindNodePair(const Edge &edge) const { + return std::make_pair(FindNode(edge.GetSrc().getNodeId()), FindNode(edge.GetDst().getNodeId())); +} + +std::pair Graph::FindNodePair(const Edge &edge) { + return std::make_pair(FindNode(edge.GetSrc().getNodeId()), FindNode(edge.GetDst().getNodeId())); +} + +void Graph::Accept(GraphVisitor &visitor) const { + visitor.Visit(*this); + std::for_each(nodes_.begin(), nodes_.end(), [&visitor](const auto &node) { visitor.Visit(node.second); }); + std::for_each(edges_.begin(), edges_.end(), [&visitor](const auto &edge) { visitor.Visit(edge); }); +} + +Status Graph::Layout(const LayoutOption *option) const { + return GraphLayout::GetInstance().Layout(*this, option); +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/graph/node.cc b/tests/framework/easy_graph/src/graph/node.cc new file mode 100644 index 00000000..bf03b9d2 --- /dev/null +++ b/tests/framework/easy_graph/src/graph/node.cc @@ -0,0 +1,49 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/graph/node.h" +#include "easy_graph/graph/graph_visitor.h" +#include + +EG_NS_BEGIN + +__DEF_EQUALS(Node) { + return id_ == rhs.id_; +} + +__DEF_COMP(Node) { + return id_ < rhs.id_; +} + +NodeId Node::GetId() const { + return id_; +} + +Node &Node::Packing(const BoxPtr &box) { + this->box_ = box; + return *this; +} + +Node &Node::AddSubgraph(const Graph &graph) { + subgraphs_.push_back(&graph); + return *this; +} + +void Node::Accept(GraphVisitor &visitor) const { + std::for_each(subgraphs_.begin(), subgraphs_.end(), [&visitor](const auto &graph) { visitor.Visit(*graph); }); +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/infra/log.cc b/tests/framework/easy_graph/src/infra/log.cc new file mode 100644 index 00000000..381dfa3d --- /dev/null +++ b/tests/framework/easy_graph/src/infra/log.cc @@ -0,0 +1,138 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include +#include +#include +#include "easy_graph/infra/log.h" + +EG_NS_BEGIN + +namespace { +struct ConsoleState { + bool isColorful() const { + return colorful; + } + + protected: + ConsoleState(bool c) : colorful(c) {} + + private: + bool colorful; +}; + +//////////////////////////////////////////////////////// +#define DEF_COLOR_STATE(STATE, COLOR) \ + struct STATE : ConsoleState { \ + STATE(bool colorful) : ConsoleState(colorful) {} \ + }; \ + std::ostream &operator<<(std::ostream &os, const STATE &state) { \ + if (state.isColorful()) \ + os << COLOR; \ + return os; \ + } + +//////////////////////////////////////////////////////// +#define __RED "\033[1;31m" +#define __GREEN "\033[1;32m" +#define __YELLOW "\033[1;33m" +#define __BLUE "\033[1;34m" +#define __MAGENTA "\033[1;35m" +#define __CYAN "\033[1;36m" +#define __WHITE "\033[0m" + +DEF_COLOR_STATE(DebugState, __BLUE) +DEF_COLOR_STATE(InfoState, __CYAN) +DEF_COLOR_STATE(NormalState, __WHITE) +DEF_COLOR_STATE(SuccState, __GREEN) +DEF_COLOR_STATE(WarnState, __YELLOW) +DEF_COLOR_STATE(FailState, __RED) + +/////////////////////////////////////////////////////// +struct StdoutListener; +StdoutListener *inst = nullptr; + +struct StdoutListener { + static StdoutListener &getInstance() { + if (inst == 0) { + inst = new StdoutListener(true); + } + + return *inst; + } + + void println(const uint8_t level, const char *msg) { +#define ON_LEVEL(level, state) \ + case level: \ + doPrint(state, msg); \ + break; + + switch (level) { + ON_LEVEL(EG_FATAL_LEVEL, fail) + ON_LEVEL(EG_ERR_LEVEL, fail) + ON_LEVEL(EG_WARN_LEVEL, warn) + ON_LEVEL(EG_SUCC_LEVEL, succ) + ON_LEVEL(EG_INFO_LEVEL, info) + ON_LEVEL(EG_DEBUG_LEVEL, debug) + default: + doPrint(normal, msg); + } + } + + private: + StdoutListener(bool colorful) + : succ(colorful), fail(colorful), normal(colorful), info(colorful), warn(colorful), debug(colorful) {} + + template + void doPrint(const STATE &state, const char *msg) { + std::cout << state << msg << normal << std::endl; + } + + private: + SuccState succ; + FailState fail; + NormalState normal; + InfoState info; + WarnState warn; + DebugState debug; +}; + +const char *getBaseName(const char *absPath) { + if (absPath == 0) + return ""; + const char *p = absPath + strlen(absPath); + while ((p != absPath) && (*(p - 1) != '/')) { + p--; + } + return p; +} + +} // namespace + +void eg_log(int level, const char *levelstr, const char *file, unsigned int line, const char *fmt, ...) { + const int FMT_BUFF_SIZE = 1024; + char fmt_buff[FMT_BUFF_SIZE] = {0}; + va_list valist; + va_start(valist, fmt); + vsnprintf(fmt_buff, FMT_BUFF_SIZE, fmt, valist); + va_end(valist); + + char buff[1280] = {0}; + sprintf(buff, "[%s]: %s:%u: %s", levelstr, getBaseName(file), line, fmt_buff); + StdoutListener::getInstance().println(level, buff); +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_executor.cc b/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_executor.cc new file mode 100644 index 00000000..0558e332 --- /dev/null +++ b/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_executor.cc @@ -0,0 +1,47 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/layout/engines/graph_easy/graph_easy_executor.h" +#include "easy_graph/layout/engines/graph_easy/graph_easy_visitor.h" +#include "easy_graph/layout/engines/graph_easy/graph_easy_option.h" +#include "layout/engines/graph_easy/utils/shell_executor.h" +#include "easy_graph/layout/layout_option.h" +#include "easy_graph/graph/graph.h" + +EG_NS_BEGIN + +namespace { +const GraphEasyOption *GraphEasyOptionCast(const LayoutOption *opts) { + if (!opts) + return &(GraphEasyOption::GetDefault()); + auto options = dynamic_cast(opts); + if (options) + return options; + return &(GraphEasyOption::GetDefault()); +} +} // namespace + +Status GraphEasyExecutor::Layout(const Graph &graph, const LayoutOption *opts) { + auto options = GraphEasyOptionCast(opts); + GraphEasyVisitor visitor(*options); + graph.Accept(visitor); + + std::string script = + std::string("echo \"") + visitor.GetLayout() + "\" | graph-easy " + options->GetLayoutCmdArgs(graph.GetName()); + return ShellExecutor::execute(script); +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_layout_context.cc b/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_layout_context.cc new file mode 100644 index 00000000..87c16c5a --- /dev/null +++ b/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_layout_context.cc @@ -0,0 +1,65 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include +#include "easy_graph/layout/engines/graph_easy/graph_easy_layout_context.h" +#include "easy_graph/layout/engines/graph_easy/graph_easy_option.h" +#include "easy_graph/graph/graph.h" + +EG_NS_BEGIN + +GraphEasyLayoutContext::GraphEasyLayoutContext(const GraphEasyOption &options) : options_(options) {} + +const Graph *GraphEasyLayoutContext::GetCurrentGraph() const { + if (graphs_.empty()) + return nullptr; + return graphs_.back(); +} + +void GraphEasyLayoutContext::EnterGraph(const Graph &graph) { + graphs_.push_back(&graph); +} + +void GraphEasyLayoutContext::ExitGraph() { + graphs_.pop_back(); +} + +void GraphEasyLayoutContext::LinkBegin() { + is_linking_ = true; +} + +void GraphEasyLayoutContext::LinkEnd() { + is_linking_ = false; +} + +bool GraphEasyLayoutContext::InLinking() const { + return is_linking_; +} + +std::string GraphEasyLayoutContext::GetGroupPath() const { + if (graphs_.empty()) + return ""; + std::string result(""); + std::for_each(graphs_.begin(), graphs_.end(), + [&result](const auto &graph) { result += (std::string("/") + graph->GetName()); }); + return (result + "/"); +} + +const GraphEasyOption &GraphEasyLayoutContext::GetOptions() const { + return options_; +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_option.cc b/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_option.cc new file mode 100644 index 00000000..d5817dfa --- /dev/null +++ b/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_option.cc @@ -0,0 +1,54 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include +#include "easy_graph/layout/engines/graph_easy/graph_easy_option.h" + +EG_NS_BEGIN + +namespace { +struct Format { + const char *format; + const char *postfix; +}; + +std::map formats = {{LayoutFormat::ASCII, {"ascii", "txt"}}, + {LayoutFormat::BOXART, {"boxart", "txt"}}, + {LayoutFormat::SVG, {"svg", "svg"}}, + {LayoutFormat::DOT, {"dot", "dot"}}, + {LayoutFormat::HTML, {"html", "html"}}}; + +std::string GetLayoutOutputArg(const GraphEasyOption &options, const std::string &graphName) { + if (options.output_ == LayoutOutput::CONSOLE) + return ""; + return std::string(" --output ") + options.output_path_ + graphName + "." + formats[options.format_].postfix; +} + +std::string GetLayoutFomartArg(const GraphEasyOption &options) { + return std::string(" --as=") + formats[options.format_].format; +} +} // namespace + +const GraphEasyOption &GraphEasyOption::GetDefault() { + static GraphEasyOption option; + return option; +} + +std::string GraphEasyOption::GetLayoutCmdArgs(const std::string &graphName) const { + return GetLayoutFomartArg(*this) + GetLayoutOutputArg(*this, graphName); +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_visitor.cc b/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_visitor.cc new file mode 100644 index 00000000..7dcdfc2d --- /dev/null +++ b/tests/framework/easy_graph/src/layout/engines/graph_easy/graph_easy_visitor.cc @@ -0,0 +1,188 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/layout/engines/graph_easy/graph_easy_visitor.h" +#include "layout/engines/graph_easy/utils/shell_executor.h" +#include "easy_graph/layout/engines/graph_easy/graph_easy_option.h" +#include "easy_graph/infra/scope_guard.h" +#include "easy_graph/graph/graph.h" +#include "easy_graph/graph/edge.h" +#include "easy_graph/graph/node.h" +#include "easy_graph/infra/log.h" + +EG_NS_BEGIN + +namespace { +struct SubgraphLayoutVisitor : GraphVisitor { + SubgraphLayoutVisitor(const NodeId &id, GraphEasyLayoutContext &ctxt) : id_(id), ctxt_(ctxt) {} + std::string layout; + bool hasSubgraph{false}; + + private: + Status Visit(const Graph &graph) override { + ScopeGuard guard([this, &graph]() { ctxt_.EnterGraph(graph); }, [this]() { ctxt_.ExitGraph(); }); + layout += (std::string(" -- [") + id_ + "/" + graph.GetName() + "]" + + "{class : subgraph; label : " + graph.GetName() + ";}"); + hasSubgraph = true; + return EG_SUCCESS; + } + + private: + NodeId id_; + GraphEasyLayoutContext &ctxt_; +}; + +///////////////////////////////////////////////////////////////////////// +std::string GetGraphLayoutTitle(const Graph &graph, const GraphEasyLayoutContext &ctxt) { + std::string flowDirection = (ctxt.GetOptions().dir_ == FlowDir::LR) ? "east" : "down"; + std::string graphTitle = std::string("graph { label : ") + graph.GetName() + "; flow : " + flowDirection + + " ; } node.subgraph { border : double-dash; }"; + return graphTitle; +} +///////////////////////////////////////////////////////////////////////// +std::string GetNodeLayout(const Node &node, GraphEasyLayoutContext &ctxt) { + const auto &id = node.GetId(); + std::string nodeBox = std::string("[") + id + "]"; + + SubgraphLayoutVisitor subgraphVisitor(id, ctxt); + node.Accept(subgraphVisitor); + + if (!subgraphVisitor.hasSubgraph || ctxt.InLinking()) + return nodeBox; + + return (std::string("( ") + id + ": " + nodeBox + subgraphVisitor.layout + ")"); +} + +///////////////////////////////////////////////////////////////////////// +INTERFACE(EdgeLayout) { + EdgeLayout(GraphEasyLayoutContext & ctxt, const Edge &edge) : ctxt_(ctxt), options_(ctxt.GetOptions()), edge_(edge) {} + + std::string GetLayout() const { + auto graph = ctxt_.GetCurrentGraph(); + if (!graph) { + EG_FATAL("Layout context has no graph!"); + return ""; + } + + auto node_pair = graph->FindNodePair(edge_); + + if ((!node_pair.first) || (!node_pair.second)) { + EG_FATAL("Layout context graph(%s) has not found node(%s, %s)!", graph->GetName().c_str(), + edge_.GetSrc().getNodeId().c_str(), edge_.GetDst().getNodeId().c_str()); + return ""; + } + + std::string src_node_layout = GetNodeLayout(*node_pair.first, ctxt_); + std::string dst_node_layout = GetNodeLayout(*node_pair.second, ctxt_); + return src_node_layout + GetArrowLayout() + GetAttrLayout() + dst_node_layout; + } + + private: + ABSTRACT(std::string GetAttrLayout() const); + ABSTRACT(std::string GetArrowLayout() const); + + protected: + GraphEasyLayoutContext &ctxt_; + const GraphEasyOption &options_; + const Edge &edge_; +}; + +///////////////////////////////////////////////////////////////////////// +struct CtrlEdgeLayout : EdgeLayout { + using EdgeLayout::EdgeLayout; + + private: + std::string GetAttrLayout() const override { + if (edge_.GetLabel() == "") + return ""; + return std::string("{label : ") + edge_.GetLabel() + "}"; + } + + std::string GetArrowLayout() const override { + return " ..> "; + } +}; + +///////////////////////////////////////////////////////////////////////// +struct DataEdgeLayout : EdgeLayout { + using EdgeLayout::EdgeLayout; + + private: + std::string GetAttrLayout() const override { + return std::string("{ ") + GetLabelAttr() + GetPortAttr() + " }"; + } + + std::string GetArrowLayout() const override { + return " --> "; + } + + private: + std::string GetPortPair() const { + return std::string("(") + std::to_string(edge_.GetSrc().getPortId()) + "," + + std::to_string(edge_.GetDst().getPortId()) + ")"; + } + + std::string GetLabelAttr() const { + return std::string("label :") + edge_.GetLabel() + GetPortPair() + "; "; + } + + std::string GetPortAttr() const { + return (options_.type_ == LayoutType::FREE) ? "" : GetOutPortAttr() + GetInPortAttr(); + } + + std::string GetOutPortAttr() const { + return std::string(" start : ") + "front" + ", " + std::to_string(edge_.GetSrc().getPortId() * options_.scale_) + + "; "; + } + + std::string GetInPortAttr() const { + return std::string(" end : ") + "back" + ", " + std::to_string(edge_.GetDst().getPortId() * options_.scale_) + "; "; + } +}; +} // namespace + +GraphEasyVisitor::GraphEasyVisitor(const GraphEasyOption &options) : ctxt_(options) {} + +Status GraphEasyVisitor::Visit(const Graph &graph) { + ctxt_.EnterGraph(graph); + layout_ += GetGraphLayoutTitle(graph, ctxt_); + return EG_SUCCESS; +} + +Status GraphEasyVisitor::Visit(const Node &node) { + layout_ += GetNodeLayout(node, ctxt_); + return EG_SUCCESS; +} + +Status GraphEasyVisitor::Visit(const Edge &edge) { + ScopeGuard guard([this]() { ctxt_.LinkBegin(); }, [this]() { ctxt_.LinkEnd(); }); + + auto makeEdgeLayout = [this, &edge]() -> const EdgeLayout * { + if (edge.GetType() == EdgeType::CTRL) + return new CtrlEdgeLayout(ctxt_, edge); + return new DataEdgeLayout(ctxt_, edge); + }; + + std::unique_ptr edgeLayout(makeEdgeLayout()); + layout_ += edgeLayout->GetLayout(); + return EG_SUCCESS; +} + +std::string GraphEasyVisitor::GetLayout() const { + return layout_; +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/layout/engines/graph_easy/utils/shell_executor.cc b/tests/framework/easy_graph/src/layout/engines/graph_easy/utils/shell_executor.cc new file mode 100644 index 00000000..d608c703 --- /dev/null +++ b/tests/framework/easy_graph/src/layout/engines/graph_easy/utils/shell_executor.cc @@ -0,0 +1,43 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include +#include +#include +#include +#include "easy_graph/infra/log.h" +#include "layout/engines/graph_easy/utils/shell_executor.h" + +EG_NS_BEGIN + +Status ShellExecutor::execute(const std::string &script) { + EG_DBG("%s", script.c_str()); + + pid_t status = system(script.c_str()); + if (-1 == status) { + EG_ERR("system execute return error!"); + return EG_FAILURE; + } + + if (WIFEXITED(status) && (0 == WEXITSTATUS(status))) + return EG_SUCCESS; + + EG_ERR("system execute {%s} exit status value = [0x%x], exit code: %d\n", script.c_str(), status, + WEXITSTATUS(status)); + return EG_FAILURE; +} + +EG_NS_END diff --git a/tests/framework/easy_graph/src/layout/engines/graph_easy/utils/shell_executor.h b/tests/framework/easy_graph/src/layout/engines/graph_easy/utils/shell_executor.h new file mode 100644 index 00000000..72477056 --- /dev/null +++ b/tests/framework/easy_graph/src/layout/engines/graph_easy/utils/shell_executor.h @@ -0,0 +1,32 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HB141A993_B14A_4A1D_A1DD_353D33AE77A2 +#define HB141A993_B14A_4A1D_A1DD_353D33AE77A2 + +#include +#include "easy_graph/eg.h" +#include "easy_graph/infra/status.h" + +EG_NS_BEGIN + +struct ShellExecutor { + static Status execute(const std::string &script); +}; + +EG_NS_END + +#endif diff --git a/tests/framework/easy_graph/src/layout/graph_layout.cc b/tests/framework/easy_graph/src/layout/graph_layout.cc new file mode 100644 index 00000000..340acf67 --- /dev/null +++ b/tests/framework/easy_graph/src/layout/graph_layout.cc @@ -0,0 +1,35 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/layout/graph_layout.h" +#include "easy_graph/layout/layout_executor.h" +#include "easy_graph/graph/graph.h" + +EG_NS_BEGIN + +void GraphLayout::Config(LayoutExecutor &executor, const LayoutOption *opts) { + this->executor_ = &executor; + options_ = opts; +} + +Status GraphLayout::Layout(const Graph &graph, const LayoutOption *opts) { + const LayoutOption *options = opts ? opts : this->options_; + if (!executor_) + return EG_UNIMPLEMENTED; + return executor_->Layout(graph, options); +} + +EG_NS_END diff --git a/tests/framework/ge_graph_dsl/CMakeLists.txt b/tests/framework/ge_graph_dsl/CMakeLists.txt new file mode 100644 index 00000000..deac4e03 --- /dev/null +++ b/tests/framework/ge_graph_dsl/CMakeLists.txt @@ -0,0 +1,18 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# 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. +# ============================================================================ + +add_subdirectory(include) +add_subdirectory(src) +add_subdirectory(tests) \ No newline at end of file diff --git a/tests/framework/ge_graph_dsl/include/CMakeLists.txt b/tests/framework/ge_graph_dsl/include/CMakeLists.txt new file mode 100644 index 00000000..3ae40204 --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/CMakeLists.txt @@ -0,0 +1,17 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# 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. +# ============================================================================ + +add_library(ge_graph_dsl_inc INTERFACE) +target_include_directories(ge_graph_dsl_inc INTERFACE ./) diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/ge.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/ge.h new file mode 100644 index 00000000..c022bf1d --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/ge.h @@ -0,0 +1,29 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H382C2083_01CC_43DF_8BBD_EF6714FF62B2 +#define H382C2083_01CC_43DF_8BBD_EF6714FF62B2 + +#define GE_NS ge +#define GE_NS_BEGIN namespace GE_NS { +#define GE_NS_END } +#define USING_GE_NS using namespace GE_NS; +#define FWD_DECL_GE(type) \ + namespace GE_NS { \ + struct type; \ + } + +#endif /* H382C2083_01CC_43DF_8BBD_EF6714FF62B2 */ diff --git a/tests/st/framework/utils/assertion/graph_assertion.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/graph_dsl.h similarity index 50% rename from tests/st/framework/utils/assertion/graph_assertion.h rename to tests/framework/ge_graph_dsl/include/ge_graph_dsl/graph_dsl.h index ffdceaf9..4e1903ae 100644 --- a/tests/st/framework/utils/assertion/graph_assertion.h +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/graph_dsl.h @@ -1,34 +1,38 @@ -/** - * Copyright 2021 Huawei Technologies Co., Ltd - * - * 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 GRAPHENGINE_LLT_ST_GRAPH_ASSERTION_H -#define GRAPHENGINE_LLT_ST_GRAPH_ASSERTION_H - -/* - * Compare graph node size, node_attr - */ -#define ASSERT_GRAPH_EQUAL(g1,g2) \ - do { \ - } while (0) - -#define ASSERT_GRAPH_CORRECT(g) \ - do { \ - } while (0) - -#define ASSERT_GRAPH_SHAPE_CONTINOUS(g) \ - do { \ - } while (0) -#endif // GRAPHENGINE_LLT_ST_GRAPH_ASSERTION_H +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H7C82E219_BDEF_4480_A2D9_30F0590C8AC5 +#define H7C82E219_BDEF_4480_A2D9_30F0590C8AC5 + +#include "easy_graph/graph/graph.h" +#include "easy_graph/builder/graph_dsl.h" +#include "ge_graph_dsl/ge.h" +#include "ge_graph_dsl/op_desc/op_desc_node_builder.h" +#include "external/graph/graph.h" + +GE_NS_BEGIN + +Graph ToGeGraph(const ::EG_NS::Graph &graph); +ComputeGraphPtr ToComputeGraph(const ::EG_NS::Graph &graph); + +#define DATA_EDGE(...) Data(__VA_ARGS__) +#define CTRL_EDGE(...) Ctrl(__VA_ARGS__) +#define NODE(...) Node(::GE_NS::OpDescNodeBuild(__VA_ARGS__)) +#define EDGE(...) DATA_EDGE(__VA_ARGS__) + +GE_NS_END + +#endif diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_box.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_box.h new file mode 100644 index 00000000..25e0f976 --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_box.h @@ -0,0 +1,33 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H6DCF6C61_7C9B_4048_BB5D_E748142FF7F8 +#define H6DCF6C61_7C9B_4048_BB5D_E748142FF7F8 + +#include "ge_graph_dsl/ge.h" +#include "easy_graph/graph/node_id.h" +#include "easy_graph/graph/box.h" +#include "external/graph/gnode.h" + +GE_NS_BEGIN + +struct OpBox : ::EG_NS::Box { + ABSTRACT(OpDescPtr Build(const ::EG_NS::NodeId &) const); +}; + +GE_NS_END + +#endif /* H6DCF6C61_7C9B_4048_BB5D_E748142FF7F8 */ diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_cfg.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_cfg.h new file mode 100644 index 00000000..bb2326ec --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_cfg.h @@ -0,0 +1,52 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H77F0BD09_6C00_4E45_8DED_38A676D6B20A +#define H77F0BD09_6C00_4E45_8DED_38A676D6B20A + +#include +#include "ge_graph_dsl/ge.h" +#include "graph/types.h" +#include "ge_graph_dsl/op_desc/op_type.h" + +GE_NS_BEGIN + +struct OpDescCfg { + struct TensorCfg { + TensorCfg(Format format = FORMAT_NCHW, DataType data_type = DT_FLOAT, std::vector shape = {1, 1, 224, 224}) + : format_(format), data_type_(data_type), shape_(shape) {} + Format format_; + DataType data_type_; + std::vector shape_; + }; + + OpDescCfg(const OpType &type, int in_cnt = 0, int out_cnt = 0, Format format = FORMAT_NCHW, + DataType data_type = DT_FLOAT, std::vector shape = {1, 1, 224, 224}) + : type_(type), in_cnt_(in_cnt), out_cnt_(out_cnt), default_tensor_(format, data_type, shape) {} + + protected: + OpType GetType() const { + return type_; + } + OpType type_; + int in_cnt_; + int out_cnt_; + TensorCfg default_tensor_; +}; + +GE_NS_END + +#endif /* H77F0BD09_6C00_4E45_8DED_38A676D6B20A */ diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_cfg_box.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_cfg_box.h new file mode 100644 index 00000000..af3a1971 --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_cfg_box.h @@ -0,0 +1,51 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HF55B1FFE_C64C_4671_8A25_A57DDD5D1280 +#define HF55B1FFE_C64C_4671_8A25_A57DDD5D1280 + +#include "easy_graph/graph/node_id.h" +#include "ge_graph_dsl/ge.h" +#include "ge_graph_dsl/op_desc/op_box.h" +#include "ge_graph_dsl/op_desc/op_desc_cfg.h" +#include "graph/op_desc.h" + +GE_NS_BEGIN + +struct OpDescCfgBox : OpBox, private OpDescCfg { + OpDescCfgBox(const OpType &opType); + OpDescCfgBox &InCnt(int in_cnt); + OpDescCfgBox &OutCnt(int out_cnt); + OpDescCfgBox &TensorDesc(Format format = FORMAT_NCHW, DataType data_type = DT_FLOAT, + std::vector shape = {1, 1, 224, 224}); + template + OpDescCfgBox& Attr(const std::string &name, Type value) { + auto attrvalue = ge::GeAttrValue::CreateFrom(value); + attrs_.emplace(std::make_pair(name, attrvalue)); + return *this; + } + + private: + OpDescPtr Build(const ::EG_NS::NodeId &id) const override; + void UpdateAttrs(OpDescPtr&) const; + std::map attrs_; +}; + +#define OP_CFG(optype) ::GE_NS::OpDescCfgBox(optype) + +GE_NS_END + +#endif /* HF55B1FFE_C64C_4671_8A25_A57DDD5D1280 */ diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_cfg_repo.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_cfg_repo.h new file mode 100644 index 00000000..275f7597 --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_cfg_repo.h @@ -0,0 +1,34 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H600DEDD4_D5B9_4803_AF48_262B2C4FBA94d +#define H600DEDD4_D5B9_4803_AF48_262B2C4FBA94c + +#include "easy_graph/infra/singleton.h" +#include "ge_graph_dsl/ge.h" +#include "ge_graph_dsl/op_desc/op_type.h" + +GE_NS_BEGIN + +struct OpDescCfg; + +SINGLETON(OpDescCfgRepo) { + const OpDescCfg *FindBy(const OpType &); +}; + +GE_NS_END + +#endif /* H600DEDD4_D5B9_4803_AF48_262B2C4FBA94 */ diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_node_builder.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_node_builder.h new file mode 100644 index 00000000..f3c0603d --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_node_builder.h @@ -0,0 +1,57 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 H53F1A984_1D06_4458_9595_0A6DC60EA9CE +#define H53F1A984_1D06_4458_9595_0A6DC60EA9CE + +#include "easy_graph/graph/node.h" +#include "ge_graph_dsl/ge.h" +#include "ge_graph_dsl/op_desc/op_desc_ptr_box.h" +#include "ge_graph_dsl/op_desc/op_desc_cfg_box.h" +#include "graph/op_desc.h" + +using ::EG_NS::Node; +using ::EG_NS::NodeId; + +GE_NS_BEGIN + +inline const ::EG_NS::NodeId OpDescNodeBuild(const ::EG_NS::NodeId &id) { + return id; +} + +template +inline ::EG_NS::Node OpDescNodeBuild(const ::EG_NS::NodeId &id, const GRAPHS &... graphs) { + return ::EG_NS::Node(id, graphs...); +} + +template +inline ::EG_NS::Node OpDescNodeBuild(const OpDescPtr &op, const GRAPHS &... graphs) { + return ::EG_NS::Node(op->GetName(), BOX_OF(::GE_NS::OpDescPtrBox, op), graphs...); +} + +template +inline ::EG_NS::Node OpDescNodeBuild(const ::EG_NS::NodeId &id, const OpType &opType, const GRAPHS &... graphs) { + return ::EG_NS::Node(id, BOX_OF(OpDescCfgBox, opType), graphs...); +} + +template +inline ::EG_NS::Node OpDescNodeBuild(const ::EG_NS::NodeId &id, const OpDescCfgBox &opBox, const GRAPHS &... graphs) { + return ::EG_NS::Node(id, BOX_OF(OpDescCfgBox, opBox), graphs...); +} + +GE_NS_END + +#endif /* H53F1A984_1D06_4458_9595_0A6DC60EA9CE */ diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_ptr_box.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_ptr_box.h new file mode 100644 index 00000000..8a45e732 --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_desc_ptr_box.h @@ -0,0 +1,38 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HCFDD0816_CC46_4264_9363_9E8C6934F43E +#define HCFDD0816_CC46_4264_9363_9E8C6934F43E + +#include "easy_graph/eg.h" +#include "easy_graph/graph/node_id.h" +#include "graph/op_desc.h" +#include "ge_graph_dsl/ge.h" +#include "ge_graph_dsl/op_desc/op_box.h" + +GE_NS_BEGIN + +struct OpDescPtrBox : OpBox { + OpDescPtrBox(const OpDescPtr &op) : op_(op) {} + + private: + OpDescPtr Build(const ::EG_NS::NodeId &id) const override; + const OpDescPtr op_; +}; + +GE_NS_END + +#endif /* HCFDD0816_CC46_4264_9363_9E8C6934F43E */ diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_type.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_type.h new file mode 100644 index 00000000..182bde3c --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/op_desc/op_type.h @@ -0,0 +1,28 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HAA2D4486_DB43_4ED2_BCF8_F41AD8267A85 +#define HAA2D4486_DB43_4ED2_BCF8_F41AD8267A85 + +#include +#include "ge_graph_dsl/ge.h" + +GE_NS_BEGIN + +using OpType = std::string; + +GE_NS_END + +#endif /* HAA2D4486_DB43_4ED2_BCF8_F41AD8267A85 */ diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/vistor/ge_graph_vistor.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/vistor/ge_graph_vistor.h new file mode 100644 index 00000000..fbb4e4c4 --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/vistor/ge_graph_vistor.h @@ -0,0 +1,44 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HD31125D4_0EB8_494C_B83D_3B8B923A914D +#define HD31125D4_0EB8_494C_B83D_3B8B923A914D + +#include "easy_graph/graph/graph_visitor.h" +#include "graph/compute_graph.h" +#include "external/graph/graph.h" +#include "ge_graph_dsl/ge.h" + +GE_NS_BEGIN + +struct GeGraphVisitor : ::EG_NS::GraphVisitor { + GeGraphVisitor(); + void reset(const ComputeGraphPtr &graph); + Graph BuildGeGraph() const; + ComputeGraphPtr BuildComputeGraph() const; + + private: + ::EG_NS::Status Visit(const ::EG_NS::Graph &) override; + ::EG_NS::Status Visit(const ::EG_NS::Node &) override; + ::EG_NS::Status Visit(const ::EG_NS::Edge &) override; + + private: + ComputeGraphPtr build_graph_; +}; + +GE_NS_END + +#endif /* TESTS_ST_EASY_GRAPH_GELAYOUT_GRAPH_GE_VISTOR_H_ */ diff --git a/tests/framework/ge_graph_dsl/include/ge_graph_dsl/vistor/ge_subgraph_vistor.h b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/vistor/ge_subgraph_vistor.h new file mode 100644 index 00000000..97418296 --- /dev/null +++ b/tests/framework/ge_graph_dsl/include/ge_graph_dsl/vistor/ge_subgraph_vistor.h @@ -0,0 +1,47 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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 HF900DC04_D202_42ED_992A_35DD7C940CE6 +#define HF900DC04_D202_42ED_992A_35DD7C940CE6 + +#include "easy_graph/infra/status.h" +#include "external/graph/gnode.h" +#include "ge_graph_dsl/ge.h" +#include "ge_graph_dsl/vistor/ge_graph_vistor.h" + +GE_NS_BEGIN + +struct GeSubgraphVisitor : ::EG_NS::GraphVisitor { + GeSubgraphVisitor(ComputeGraphPtr &, const ::EG_NS::Node &); + ::EG_NS::Status BuildGraphRelations(); + + private: + ::EG_NS::Status Visit(const ::EG_NS::Graph &) override; + ::EG_NS::Status Visit(const ::EG_NS::Node &) override; + ::EG_NS::Status Visit(const ::EG_NS::Edge &) override; + + private: + ::EG_NS::Status BuildGraphRelations(OpDescPtr &); + + private: + ComputeGraphPtr &root_graph_; + const ::EG_NS::Node &node_; + GeGraphVisitor cur_graph_vistor_; + std::vector subgraphs_; +}; + +GE_NS_END + +#endif /* HF900DC04_D202_42ED_992A_35DD7C940CE6 */ diff --git a/tests/framework/ge_graph_dsl/src/CMakeLists.txt b/tests/framework/ge_graph_dsl/src/CMakeLists.txt new file mode 100644 index 00000000..c92c6b5c --- /dev/null +++ b/tests/framework/ge_graph_dsl/src/CMakeLists.txt @@ -0,0 +1,28 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# 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. +# ============================================================================ + +file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS "*.cc" "*.CC" "*.cpp" "*.CPP") + +add_library(ge_graph_dsl STATIC ${SOURCES}) + +target_include_directories(ge_graph_dsl + PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} +) + +target_link_libraries(ge_graph_dsl PUBLIC + $) + +set_target_properties(ge_graph_dsl PROPERTIES CXX_STANDARD 17) +target_link_libraries(ge_graph_dsl PUBLIC ge_graph_dsl_inc easy_graph metadef_graph) diff --git a/tests/framework/ge_graph_dsl/src/ge_graph_vistor.cc b/tests/framework/ge_graph_dsl/src/ge_graph_vistor.cc new file mode 100644 index 00000000..d8bc2aab --- /dev/null +++ b/tests/framework/ge_graph_dsl/src/ge_graph_vistor.cc @@ -0,0 +1,79 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ +#include "easy_graph/graph/edge.h" +#include "easy_graph/graph/graph.h" +#include "easy_graph/graph/node.h" +#include "easy_graph/graph/edge_type.h" +#include "easy_graph/builder/box_builder.h" + +#include "external/graph/types.h" +#include "graph/utils/graph_utils.h" +#include "graph/compute_graph.h" +#include "graph/ge_tensor.h" + +#include "framework/common/types.h" +#include "ge_graph_dsl/op_desc/op_box.h" +#include "ge_graph_dsl/op_desc/op_desc_cfg_box.h" +#include "ge_graph_dsl/vistor/ge_graph_vistor.h" +#include "ge_graph_dsl/vistor/ge_subgraph_vistor.h" + +using ::EG_NS::Status; + +GE_NS_BEGIN + +GeGraphVisitor::GeGraphVisitor() : build_graph_(std::make_shared("")) {} + +void GeGraphVisitor::reset(const ComputeGraphPtr &graph) { + build_graph_ = graph; +} + +Graph GeGraphVisitor::BuildGeGraph() const { + return GraphUtils::CreateGraphFromComputeGraph(build_graph_); +} + +ComputeGraphPtr GeGraphVisitor::BuildComputeGraph() const { + return build_graph_; +} + +Status GeGraphVisitor::Visit(const ::EG_NS::Graph &graph) { + build_graph_->SetName(graph.GetName()); + return EG_SUCCESS; +} + +Status GeGraphVisitor::Visit(const ::EG_NS::Node &node) { + GeSubgraphVisitor vistor(build_graph_, node); + return vistor.BuildGraphRelations(); +} + +Status GeGraphVisitor::Visit(const ::EG_NS::Edge &edge) { + auto src_node = build_graph_->FindNode(edge.GetSrc().getNodeId()); + auto dst_node = build_graph_->FindNode(edge.GetDst().getNodeId()); + + if (edge.GetType() == ::EG_NS::EdgeType::CTRL) { + GraphUtils::AddEdge(src_node->GetOutControlAnchor(), dst_node->GetInControlAnchor()); + return EG_SUCCESS; + } + + if (src_node->GetAllOutDataAnchorsSize() <= edge.GetSrc().getPortId() || + dst_node->GetAllInDataAnchorsSize() <= edge.GetDst().getPortId()) { + return EG_FAILURE; + } + GraphUtils::AddEdge(src_node->GetOutDataAnchor(edge.GetSrc().getPortId()), + dst_node->GetInDataAnchor(edge.GetDst().getPortId())); + return EG_SUCCESS; +} + +GE_NS_END diff --git a/tests/framework/ge_graph_dsl/src/ge_subgraph_vistor.cc b/tests/framework/ge_graph_dsl/src/ge_subgraph_vistor.cc new file mode 100644 index 00000000..d16ca3b7 --- /dev/null +++ b/tests/framework/ge_graph_dsl/src/ge_subgraph_vistor.cc @@ -0,0 +1,70 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/graph/node.h" +#include "easy_graph/graph/graph.h" +#include "easy_graph/graph/edge.h" +#include "ge_graph_dsl/op_desc/op_box.h" +#include "ge_graph_dsl/vistor/ge_subgraph_vistor.h" + +GE_NS_BEGIN + +GeSubgraphVisitor::GeSubgraphVisitor(ComputeGraphPtr &rootGraph, const ::EG_NS::Node &node) + : root_graph_(rootGraph), node_(node) {} + +::EG_NS::Status GeSubgraphVisitor::BuildGraphRelations() { + node_.Accept(*this); + auto nod_builder = node_.Unpacking(); + if (nod_builder == nullptr) { + return EG_FAILURE; + } else { + auto opPtr = nod_builder->Build(node_.GetId()); + return BuildGraphRelations(opPtr); + } +} + +::EG_NS::Status GeSubgraphVisitor::BuildGraphRelations(OpDescPtr &opPtr) { + auto node = root_graph_->AddNode(opPtr); + int graph_index = 0; + for (auto subGraph : subgraphs_) { + opPtr->AddSubgraphName(subGraph->GetName()); + opPtr->SetSubgraphInstanceName(graph_index++, subGraph->GetName()); + subGraph->SetParentNode(node); + subGraph->SetParentGraph(root_graph_); + root_graph_->AddSubgraph(subGraph); + } + return EG_SUCCESS; +} + +::EG_NS::Status GeSubgraphVisitor::Visit(const ::EG_NS::Graph &graph) { + auto subgraph = std::make_shared(graph.GetName()); + cur_graph_vistor_.reset(subgraph); + graph.Accept(cur_graph_vistor_); + subgraphs_.push_back(subgraph); + return EG_SUCCESS; +} + +::EG_NS::Status GeSubgraphVisitor::Visit(const ::EG_NS::Node &node) { + ::EG_NS::GraphVisitor &vistor = cur_graph_vistor_; + return vistor.Visit(node); +} + +::EG_NS::Status GeSubgraphVisitor::Visit(const ::EG_NS::Edge &edge) { + ::EG_NS::GraphVisitor &vistor = cur_graph_vistor_; + return vistor.Visit(edge); +} + +GE_NS_END diff --git a/tests/framework/ge_graph_dsl/src/graph_dsl.cc b/tests/framework/ge_graph_dsl/src/graph_dsl.cc new file mode 100644 index 00000000..d2d297f9 --- /dev/null +++ b/tests/framework/ge_graph_dsl/src/graph_dsl.cc @@ -0,0 +1,39 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "easy_graph/builder/graph_dsl.h" +#include "easy_graph/graph/graph.h" +#include "external/graph/graph.h" +#include "ge_graph_dsl/graph_dsl.h" +#include "ge_graph_dsl/vistor/ge_graph_vistor.h" + +GE_NS_BEGIN + +Graph ToGeGraph(const ::EG_NS::Graph &graph) { + graph.Layout(); + GeGraphVisitor geVistor; + graph.Accept(geVistor); + return geVistor.BuildGeGraph(); +} + +ComputeGraphPtr ToComputeGraph(const ::EG_NS::Graph &graph) { + graph.Layout(); + GeGraphVisitor geVistor; + graph.Accept(geVistor); + return geVistor.BuildComputeGraph(); +} + +GE_NS_END diff --git a/tests/framework/ge_graph_dsl/src/op_desc_cfg_box.cc b/tests/framework/ge_graph_dsl/src/op_desc_cfg_box.cc new file mode 100644 index 00000000..fc2a6c1c --- /dev/null +++ b/tests/framework/ge_graph_dsl/src/op_desc_cfg_box.cc @@ -0,0 +1,75 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "ge_graph_dsl/op_desc/op_desc_cfg_box.h" +#include "easy_graph/infra/status.h" +#include "ge_graph_dsl/op_desc/op_desc_cfg_repo.h" +#include "ge_graph_dsl/op_desc/op_desc_cfg.h" +#include "external/graph/gnode.h" +#include "graph/ge_tensor.h" + +using ::EG_NS::Status; +using ::GE_NS::OpDescCfg; + +GE_NS_BEGIN + +OpDescCfgBox::OpDescCfgBox(const OpType &opType) : OpDescCfg(opType) { + auto opCfg = OpDescCfgRepo::GetInstance().FindBy(opType); + if (opCfg != nullptr) { + ::OpDescCfg &base = *this; + base = (*opCfg); + } +} + +OpDescCfgBox &OpDescCfgBox::InCnt(int in_cnt) { + this->in_cnt_ = in_cnt; + return *this; +} + +OpDescCfgBox &OpDescCfgBox::OutCnt(int out_cnt) { + this->out_cnt_ = out_cnt; + return *this; +} + +OpDescCfgBox &OpDescCfgBox::TensorDesc(Format format, DataType data_type, std::vector shape) { + default_tensor_.format_ = format; + default_tensor_.data_type_ = data_type; + default_tensor_.shape_ = shape; + return *this; +} + +void OpDescCfgBox::UpdateAttrs(OpDescPtr& op_desc) const { + std::for_each(attrs_.begin(), attrs_.end(), [&op_desc](const auto &attr){ + op_desc->SetAttr(attr.first, attr.second); + }); +} + +OpDescPtr OpDescCfgBox::Build(const ::EG_NS::NodeId &id) const { + auto opPtr = std::make_shared(id, GetType()); + GeTensorDesc tensor_desc(ge::GeShape(default_tensor_.shape_), default_tensor_.format_, default_tensor_.data_type_); + for (int i = 0; i < in_cnt_; i++) { + opPtr->AddInputDesc(tensor_desc); + } + + for (int i = 0; i < out_cnt_; i++) { + opPtr->AddOutputDesc(tensor_desc); + } + + UpdateAttrs(opPtr); + return opPtr; +} + +GE_NS_END diff --git a/tests/framework/ge_graph_dsl/src/op_desc_cfg_repo.cc b/tests/framework/ge_graph_dsl/src/op_desc_cfg_repo.cc new file mode 100644 index 00000000..e7fa018f --- /dev/null +++ b/tests/framework/ge_graph_dsl/src/op_desc_cfg_repo.cc @@ -0,0 +1,46 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "ge_graph_dsl/op_desc/op_desc_cfg_repo.h" +#include "framework/common/types.h" +#include "graph/debug/ge_attr_define.h" +#include "ge_graph_dsl/op_desc/op_desc_cfg.h" + +GE_NS_BEGIN + +namespace { + +#define OP_CFG(optype, ...) \ + { \ + optype, OpDescCfg { \ + optype, __VA_ARGS__ \ + } \ + } + +static std::map cfg_repo{OP_CFG(DATA, 1, 1, FORMAT_NCHW, DT_FLOAT, {1, 1, 224, 224}), + OP_CFG(ADD, 2, 1, FORMAT_NCHW, DT_FLOAT, {1, 1, 224, 224}), + OP_CFG(VARIABLE, 1, 1)}; +} // namespace + +const OpDescCfg *OpDescCfgRepo::FindBy(const OpType &id) { + auto it = cfg_repo.find(id); + if (it == cfg_repo.end()) { + return nullptr; + } + return &(it->second); +} + +GE_NS_END diff --git a/tests/st/framework/utils/assertion/graph_assertion.cc b/tests/framework/ge_graph_dsl/src/op_desc_ptr_box.cc similarity index 77% rename from tests/st/framework/utils/assertion/graph_assertion.cc rename to tests/framework/ge_graph_dsl/src/op_desc_ptr_box.cc index 52c49971..23d4773c 100644 --- a/tests/st/framework/utils/assertion/graph_assertion.cc +++ b/tests/framework/ge_graph_dsl/src/op_desc_ptr_box.cc @@ -1,17 +1,24 @@ -/** - * Copyright 2021 Huawei Technologies Co., Ltd - * - * 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. - */ - -#include "graph_assertion.h" +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "ge_graph_dsl/op_desc/op_desc_ptr_box.h" +#include "external/graph/gnode.h" + +USING_GE_NS + +OpDescPtr OpDescPtrBox::Build(const ::EG_NS::NodeId &id) const { + return op_; +} diff --git a/tests/framework/ge_graph_dsl/tests/CMakeLists.txt b/tests/framework/ge_graph_dsl/tests/CMakeLists.txt new file mode 100644 index 00000000..40097d8b --- /dev/null +++ b/tests/framework/ge_graph_dsl/tests/CMakeLists.txt @@ -0,0 +1,33 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# 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. +# ============================================================================ + +file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS "*.cc" "*.CC" "*.cpp" "*.CPP") + +add_executable(ge_graph_dsl_test ${SOURCES}) + +target_include_directories(ge_graph_dsl_test + PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} +) + +target_compile_options(ge_graph_dsl_test PRIVATE + -g +) +set_target_properties(ge_graph_dsl_test PROPERTIES CXX_STANDARD 17) + +target_link_libraries(ge_graph_dsl_test PUBLIC gtest gtest_main ge_graph_dsl) + +include(CTest) +enable_testing() +add_test(NAME test COMMAND ge_graph_dsl_test) \ No newline at end of file diff --git a/tests/framework/ge_graph_dsl/tests/graph_dsl_test.cc b/tests/framework/ge_graph_dsl/tests/graph_dsl_test.cc new file mode 100644 index 00000000..f7e55e3d --- /dev/null +++ b/tests/framework/ge_graph_dsl/tests/graph_dsl_test.cc @@ -0,0 +1,218 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "gtest/gtest.h" +#include +#include "easy_graph/graph/box.h" +#include "easy_graph/graph/node.h" +#include "easy_graph/builder/graph_dsl.h" +#include "easy_graph/builder/box_builder.h" +#include "easy_graph/layout/graph_layout.h" +#include "easy_graph/layout/engines/graph_easy/graph_easy_option.h" +#include "easy_graph/layout/engines/graph_easy/graph_easy_executor.h" +#include "graph/graph.h" +#include "graph/compute_graph.h" +#include "framework/common/types.h" +#include "graph/debug/ge_attr_define.h" +#include "ge_graph_dsl/graph_dsl.h" +#include "ge_graph_dsl/op_desc/op_desc_cfg_box.h" + +USING_GE_NS + +class GraphDslTest : public testing::Test { + private: + EG_NS::GraphEasyExecutor executor; + + protected: + void SetUp() { + EG_NS::GraphLayout::GetInstance().Config(executor, nullptr); + } + + void TearDown() {} +}; + +TEST_F(GraphDslTest, test_build_graph_from_optype_with_name) { + DEF_GRAPH(g1) { + CHAIN(NODE("data1", DATA)->NODE("add", ADD)); + }); + + auto geGraph = ToGeGraph(g1); + auto computeGraph = ToComputeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 2); + ASSERT_EQ(computeGraph->GetAllNodesSize(), 2); +} + +TEST_F(GraphDslTest, test_build_graph_with_name) { + DEF_GRAPH(g1, "sample_graph") { + CHAIN(NODE("data1", DATA)->NODE("add", ADD)); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 2); + ASSERT_EQ(geGraph.GetName(), "sample_graph"); +} + +TEST_F(GraphDslTest, test_build_from_from_op_desc_ptr) { + DEF_GRAPH(g1) { + auto data = std::make_shared("data1", DATA); + auto add = std::make_shared("Add", ADD); + CHAIN(NODE(data)->NODE(add)); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 2); +} + +TEST_F(GraphDslTest, test_build_from_op_desc_cfg) { + DEF_GRAPH(g1) { + auto datCfg = OP_CFG(DATA).InCnt(1).OutCnt(1); + auto addCfg = OP_CFG(DATA).InCnt(1).OutCnt(1); + CHAIN(NODE("data1", datCfg)->NODE("add", addCfg)); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 2); +} + +TEST_F(GraphDslTest, test_build_from_op_desc_cfg_inline) { + DEF_GRAPH(g1) { + CHAIN(NODE("data1", OP_CFG(DATA).InCnt(1).OutCnt(1))->NODE("add", OP_CFG(ADD).InCnt(2).OutCnt(1))); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 2); +} + +TEST_F(GraphDslTest, test_build_from_control_chain) { + DEF_GRAPH(g1) { + CTRL_CHAIN(NODE("data1", DATA)->NODE("add", ADD)); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 2); +} + +TEST_F(GraphDslTest, test_build_from_data_chain) { + DEF_GRAPH(g1) { + DATA_CHAIN(NODE("data1", DATA)->NODE("add", ADD)); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 2); +} + +TEST_F(GraphDslTest, test_build_from_data_chain_with_edge) { + DEF_GRAPH(g1) { + CTRL_CHAIN(NODE("data1", DATA)->NODE("add", ADD)); + CHAIN(NODE("data1", DATA)->EDGE(2, 2)->NODE("add")); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 2); +} + +TEST_F(GraphDslTest, test_build_graph_reused_before_node) { + DEF_GRAPH(g1) { + CTRL_CHAIN(NODE("data1", DATA)->NODE("add", ADD)); + CHAIN(NODE("data1")->EDGE(2, 2)->NODE("add")); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 2); +} + +TEST_F(GraphDslTest, test_build_graph_with_constant_folding) { + DEF_GRAPH(g1) { + CHAIN(NODE("data1", DATA)->NODE("add", ADD)); + CHAIN(NODE("data2", DATA)->NODE("add")); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 3); +} + +TEST_F(GraphDslTest, test_build_complex_normal_graph_build_suggested) { + DEF_GRAPH(g1) { + CHAIN(NODE("w1", VARIABLE)->NODE("prefetch1", HCOMALLGATHER)->NODE("Add1", ADD)); + CHAIN(NODE("w2", VARIABLE)->NODE("prefetch2", HCOMALLGATHER)->NODE("Add2", ADD)); + CHAIN(NODE("w3", VARIABLE)->NODE("prefetch3", HCOMALLGATHER)->NODE("Add3", ADD)); + CHAIN(NODE("w4", VARIABLE)->NODE("prefetch4", HCOMALLGATHER)->NODE("Add4", ADD)); + CHAIN(NODE("w5", VARIABLE)->NODE("prefetch5", HCOMALLGATHER)->NODE("Add5", ADD)); + CHAIN(NODE("const1", CONSTANTOP) + ->NODE("Add1") + ->NODE("Add2") + ->NODE("Add3") + ->NODE("Add4") + ->NODE("Add5") + ->NODE("net_output", NETOUTPUT)); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 17); +} + +TEST_F(GraphDslTest, test_build_complex_mult_normal_graph_build) { + DEF_GRAPH(g1) { + CHAIN(NODE("w1", VARIABLE)->NODE("prefetch1", HCOMALLGATHER)->NODE("add1", ADD)); + CHAIN(NODE("w2", VARIABLE)->NODE("prefetch2", HCOMALLGATHER)->NODE("add1")); + CHAIN(NODE("w3", VARIABLE)->NODE("prefetch3", HCOMALLGATHER)->NODE("add2", ADD)); + CHAIN(NODE("w4", VARIABLE)->NODE("prefetch4", HCOMALLGATHER)->NODE("add2")); + CHAIN(NODE("w5", VARIABLE)->NODE("prefetch5", HCOMALLGATHER)->NODE("add3", ADD)); + CHAIN(NODE("const1", CONSTANTOP)->NODE("add3")); + CHAIN(NODE("add1")->NODE("net_output", NETOUTPUT)); + CHAIN(NODE("add2")->NODE("net_output")); + CHAIN(NODE("add3")->NODE("net_output")); + CTRL_CHAIN(NODE("add1")->NODE("add2")->NODE("add3")); + }); + + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 15); +} + +TEST_F(GraphDslTest, test_build_graph_with_sub_graph) { + DEF_GRAPH(sub_1) { + CHAIN(NODE("data_i", DATA)->NODE("less", LESS)->NODE("netoutput", NETOUTPUT)); + CHAIN(NODE("const_5", CONSTANTOP)->NODE("less")); + }); + + DEF_GRAPH(sub_2) { + CHAIN(NODE("data_a", DATA)->NODE("mul", MUL)->NODE("netoutput", NETOUTPUT)); + CHAIN(NODE("const_2", CONSTANTOP)->NODE("mul")); + }); + + DEF_GRAPH(g1) { + CHAIN(NODE("data_a", DATA)->NODE("while", WHILE, sub_1, sub_2)->NODE("netoutput", NETOUTPUT)); + CHAIN(NODE("data_i", DATA)->NODE("while")); + }); + + sub_1.Layout(); + sub_2.Layout(); + auto geGraph = ToGeGraph(g1); + + ASSERT_EQ(geGraph.GetAllNodes().size(), 12); +} diff --git a/tests/framework/ge_graph_dsl/tests/stub/optype_stub.cc b/tests/framework/ge_graph_dsl/tests/stub/optype_stub.cc new file mode 100644 index 00000000..b83d68fc --- /dev/null +++ b/tests/framework/ge_graph_dsl/tests/stub/optype_stub.cc @@ -0,0 +1,33 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * 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. + */ + +#include "framework/common/types.h" +#include "graph/debug/ge_attr_define.h" +#include "ge_graph_dsl/ge.h" + +GE_NS_BEGIN + +REGISTER_OPTYPE_DEFINE(DATA, "Data"); +REGISTER_OPTYPE_DEFINE(HCOMALLGATHER, "HcomAllGather"); +REGISTER_OPTYPE_DEFINE(VARIABLE, "Variable"); +REGISTER_OPTYPE_DEFINE(CONSTANTOP, "Constant"); +REGISTER_OPTYPE_DEFINE(LESS, "Less"); +REGISTER_OPTYPE_DEFINE(MUL, "Mul"); +REGISTER_OPTYPE_DEFINE(NETOUTPUT, "NetOutput"); +REGISTER_OPTYPE_DEFINE(ADD, "Add"); +REGISTER_OPTYPE_DEFINE(WHILE, "While"); + +GE_NS_END diff --git a/tests/st/framework/CMakeLists.txt b/tests/framework/stub_engine/CMakeLists.txt similarity index 78% rename from tests/st/framework/CMakeLists.txt rename to tests/framework/stub_engine/CMakeLists.txt index 17ef9a8b..c86313c7 100644 --- a/tests/st/framework/CMakeLists.txt +++ b/tests/framework/stub_engine/CMakeLists.txt @@ -31,20 +31,14 @@ list(APPEND INCLUDE_DIRECTORIES ) file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS "*.cc" "*.CC" "*.cpp" "*.CPP" "*.c++") -#todo -file(GLOB_RECURSE STUB_ENGINE_SRC CONFIGURE_DEPENDS - "stub_engine/*.cc" - ) -# ---- Target : stub Host engine ---- -add_library(fe SHARED ${STUB_ENGINE_SRC}) +# ---- Target : stub Host engine ---- +add_library(fe SHARED ${SOURCES}) target_include_directories(fe PUBLIC ${INCLUDE_DIRECTORIES} - ${GE_CODE_DIR}/tests/st/framework ${CMAKE_CURRENT_SOURCE_DIR} - ${CMAKE_CURRENT_SOURCE_DIR}/stub_engine ) target_compile_definitions(fe PRIVATE @@ -62,16 +56,3 @@ target_link_libraries(fe PUBLIC ) set_target_properties(fe PROPERTIES CXX_STANDARD 11) - -# ---- Target : framework ---- -list(REMOVE_ITEM SOURCES ${STUB_ENGINE_SRC}) - -add_library(framework STATIC ${SOURCES}) - -target_include_directories(framework - PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} -) - -set_target_properties(framework PROPERTIES CXX_STANDARD 11) - -target_link_libraries(framework PUBLIC graphengine fe) diff --git a/tests/st/framework/stub_engine/engine/stub_engine.cc b/tests/framework/stub_engine/engine/stub_engine.cc similarity index 94% rename from tests/st/framework/stub_engine/engine/stub_engine.cc rename to tests/framework/stub_engine/engine/stub_engine.cc index 6d01b26d..622e8c4e 100644 --- a/tests/st/framework/stub_engine/engine/stub_engine.cc +++ b/tests/framework/stub_engine/engine/stub_engine.cc @@ -51,7 +51,9 @@ void StubEngine::GetGraphOptimizerObjs(std::map // no optimizer for host cpu engine } -Status StubEngine::Finalize() { return SUCCESS; } +Status StubEngine::Finalize() { + return SUCCESS; +} } // namespace st } // namespace ge @@ -67,4 +69,6 @@ void GetGraphOptimizerObjs(std::map &graph_optim ge::st::StubEngine::Instance().GetGraphOptimizerObjs(graph_optimizers); } -ge::Status Finalize() { return ge::st::StubEngine::Instance().Finalize(); } +ge::Status Finalize() { + return ge::st::StubEngine::Instance().Finalize(); +} diff --git a/tests/st/framework/stub_engine/engine/stub_engine.h b/tests/framework/stub_engine/engine/stub_engine.h similarity index 100% rename from tests/st/framework/stub_engine/engine/stub_engine.h rename to tests/framework/stub_engine/engine/stub_engine.h diff --git a/tests/st/framework/inc/st_types.h b/tests/framework/stub_engine/inc/st_types.h similarity index 82% rename from tests/st/framework/inc/st_types.h rename to tests/framework/stub_engine/inc/st_types.h index 1cda682f..92aa00d9 100644 --- a/tests/st/framework/inc/st_types.h +++ b/tests/framework/stub_engine/inc/st_types.h @@ -25,9 +25,9 @@ const std::string kAicpuAscendLibName = "AicpuAscendLib"; const std::string kHcclLibName = "HcclLib"; const std::string kRTSLibName = "RTSLib"; const std::map kStubEngine2KernelLib = { - {"AIcoreEngine", "AiCoreLib"}, {"VectorEngine", "VectorLib"}, - {"DNN_VM_AICPU", "AicpuLib"}, {"DNN_VM_AICPU_ASCEND", "AicpuAscendLib"}, - {"DNN_HCCL", "HcclLib"}, {"DNN_VM_RTS", "RTSLib"}}; + {"AIcoreEngine", "AiCoreLib"}, {"VectorEngine", "VectorLib"}, + {"DNN_VM_AICPU", "AicpuLib"}, {"DNN_VM_AICPU_ASCEND", "AicpuAscendLib"}, + {"DNN_HCCL", "HcclLib"}, {"DNN_VM_RTS", "RTSLib"}}; } // namespace st } // namespace ge #endif // GRAPHENGINE_ST_TYPES_H diff --git a/tests/st/framework/stub_engine/ops_kernel_store/op/host_op.cc b/tests/framework/stub_engine/ops_kernel_store/op/host_op.cc similarity index 99% rename from tests/st/framework/stub_engine/ops_kernel_store/op/host_op.cc rename to tests/framework/stub_engine/ops_kernel_store/op/host_op.cc index a9d6be74..42678148 100644 --- a/tests/st/framework/stub_engine/ops_kernel_store/op/host_op.cc +++ b/tests/framework/stub_engine/ops_kernel_store/op/host_op.cc @@ -19,7 +19,6 @@ #include "framework/common/util.h" #include "stub_engine/ops_kernel_store/op/stub_op_factory.h" - namespace ge { namespace st { Status HostOp::Run() { diff --git a/tests/st/framework/stub_engine/ops_kernel_store/op/host_op.h b/tests/framework/stub_engine/ops_kernel_store/op/host_op.h similarity index 100% rename from tests/st/framework/stub_engine/ops_kernel_store/op/host_op.h rename to tests/framework/stub_engine/ops_kernel_store/op/host_op.h diff --git a/tests/st/framework/stub_engine/ops_kernel_store/op/op.h b/tests/framework/stub_engine/ops_kernel_store/op/op.h similarity index 100% rename from tests/st/framework/stub_engine/ops_kernel_store/op/op.h rename to tests/framework/stub_engine/ops_kernel_store/op/op.h diff --git a/tests/st/framework/stub_engine/ops_kernel_store/op/stub_op_factory.cc b/tests/framework/stub_engine/ops_kernel_store/op/stub_op_factory.cc similarity index 100% rename from tests/st/framework/stub_engine/ops_kernel_store/op/stub_op_factory.cc rename to tests/framework/stub_engine/ops_kernel_store/op/stub_op_factory.cc diff --git a/tests/st/framework/stub_engine/ops_kernel_store/op/stub_op_factory.h b/tests/framework/stub_engine/ops_kernel_store/op/stub_op_factory.h similarity index 87% rename from tests/st/framework/stub_engine/ops_kernel_store/op/stub_op_factory.h rename to tests/framework/stub_engine/ops_kernel_store/op/stub_op_factory.h index 35f7de80..f41fd07e 100644 --- a/tests/st/framework/stub_engine/ops_kernel_store/op/stub_op_factory.h +++ b/tests/framework/stub_engine/ops_kernel_store/op/stub_op_factory.h @@ -53,17 +53,21 @@ class GE_FUNC_VISIBILITY OpFactory { */ void RegisterCreator(const std::string &type, const std::string &lib_name, const OP_CREATOR_FUNC &func); - const std::vector &GetAllOps() const { return all_ops_; } + const std::vector &GetAllOps() const { + return all_ops_; + } const std::vector &GetAllOps(std::string lib_name) const { auto iter = all_store_ops_.find(lib_name); - if(iter == all_store_ops_.end()){ + if (iter == all_store_ops_.end()) { return all_ops_; } return iter->second; } - bool CheckSupported(const std::string &type) { return op_creator_map_.find(type) != op_creator_map_.end(); } + bool CheckSupported(const std::string &type) { + return op_creator_map_.find(type) != op_creator_map_.end(); + } OpFactory(const OpFactory &) = delete; OpFactory &operator=(const OpFactory &) = delete; @@ -94,10 +98,10 @@ class GE_FUNC_VISIBILITY OpRegistrar { OpRegistrar &operator=(OpRegistrar &&) = delete; }; -#define REGISTER_OP_CREATOR(type, lib_name, clazz) \ - std::shared_ptr Creator_##type##Op(const Node &node, RunContext &run_context) { \ - return MakeShared(node, run_context); \ - } \ +#define REGISTER_OP_CREATOR(type, lib_name, clazz) \ + std::shared_ptr Creator_##type##Op(const Node &node, RunContext &run_context) { \ + return MakeShared(node, run_context); \ + } \ OpRegistrar g_##type##Op_creator(#type, #lib_name, Creator_##type##Op) } // namespace st } // namespace ge diff --git a/tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.cc b/tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.cc similarity index 92% rename from tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.cc rename to tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.cc index d0b29e4b..2de8691f 100644 --- a/tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.cc +++ b/tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.cc @@ -36,8 +36,12 @@ REGISTER_OPS_KERNEL_BUILDER(kAicpuAscendLibName, StubOpsKernelBuilder); REGISTER_OPS_KERNEL_BUILDER(kHcclLibName, StubOpsKernelBuilder); REGISTER_OPS_KERNEL_BUILDER(kRTSLibName, StubOpsKernelBuilder); -Status StubOpsKernelBuilder::Finalize() { return SUCCESS; } -Status StubOpsKernelBuilder::Initialize(const map &options) { return SUCCESS; } +Status StubOpsKernelBuilder::Finalize() { + return SUCCESS; +} +Status StubOpsKernelBuilder::Initialize(const map &options) { + return SUCCESS; +} Status StubOpsKernelBuilder::CalcOpRunningParam(Node &ge_node) { OpDescPtr op_desc = ge_node.GetOpDesc(); @@ -82,9 +86,9 @@ Status StubOpsKernelBuilder::CalcOpRunningParam(Node &ge_node) { name.c_str(), type.c_str(), i, output_mem_size, TypeUtils::FormatToSerialString(format).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str()); REPORT_CALL_ERROR( - "E19999", "CalcTensorMemSize failed for op[%s:%s] out[%zu] mem size, mem_size=%ld, format=%s, data_type=%s.", - name.c_str(), type.c_str(), i, output_mem_size, TypeUtils::FormatToSerialString(format).c_str(), - TypeUtils::DataTypeToSerialString(data_type).c_str()); + "E19999", "CalcTensorMemSize failed for op[%s:%s] out[%zu] mem size, mem_size=%ld, format=%s, data_type=%s.", + name.c_str(), type.c_str(), i, output_mem_size, TypeUtils::FormatToSerialString(format).c_str(), + TypeUtils::DataTypeToSerialString(data_type).c_str()); return FAILED; } GELOGI("Calc op[%s:%s] out[%zu] mem size is %ld, format=%s, data_type=%s.", name.c_str(), type.c_str(), i, diff --git a/tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.h b/tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.h similarity index 100% rename from tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.h rename to tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.h diff --git a/tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.cc b/tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.cc similarity index 98% rename from tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.cc rename to tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.cc index 6aeb4d1e..d43fee88 100644 --- a/tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.cc +++ b/tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.cc @@ -63,7 +63,9 @@ Status StubOpsKernelInfoStore::Finalize() { return SUCCESS; } -void StubOpsKernelInfoStore::GetAllOpsKernelInfo(map &infos) const { infos = op_info_map_; } +void StubOpsKernelInfoStore::GetAllOpsKernelInfo(map &infos) const { + infos = op_info_map_; +} bool StubOpsKernelInfoStore::CheckSupported(const OpDescPtr &op_desc, std::string &) const { if (op_desc == nullptr) { diff --git a/tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.h b/tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.h similarity index 96% rename from tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.h rename to tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.h index 769a4807..ea7f712b 100644 --- a/tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.h +++ b/tests/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.h @@ -53,7 +53,9 @@ class GE_FUNC_VISIBILITY StubOpsKernelInfoStore : public OpsKernelInfoStore { Status Finalize() override; bool CheckSupported(const OpDescPtr &op_desc, std::string &reason) const override; void GetAllOpsKernelInfo(std::map &infos) const override; - std::string GetOpsKernelStoreName() const { return store_name_; } + std::string GetOpsKernelStoreName() const { + return store_name_; + } StubOpsKernelInfoStore(const StubOpsKernelInfoStore &ops_kernel_store) = delete; StubOpsKernelInfoStore(const StubOpsKernelInfoStore &&ops_kernel_store) = delete; diff --git a/tests/st/framework/utils/builder/graph_builder_utils.cc b/tests/framework/utils/builder/graph_builder_utils.cc similarity index 100% rename from tests/st/framework/utils/builder/graph_builder_utils.cc rename to tests/framework/utils/builder/graph_builder_utils.cc diff --git a/tests/st/framework/utils/builder/graph_builder_utils.h b/tests/framework/utils/builder/graph_builder_utils.h similarity index 93% rename from tests/st/framework/utils/builder/graph_builder_utils.h rename to tests/framework/utils/builder/graph_builder_utils.h index cf1cff2e..4627f082 100644 --- a/tests/st/framework/utils/builder/graph_builder_utils.h +++ b/tests/framework/utils/builder/graph_builder_utils.h @@ -29,7 +29,9 @@ namespace ge { namespace st { class ComputeGraphBuilder { public: - explicit ComputeGraphBuilder(const std::string &name) { graph_ = std::make_shared(name); } + explicit ComputeGraphBuilder(const std::string &name) { + graph_ = std::make_shared(name); + } NodePtr AddNode(const std::string &name, const std::string &type, int in_cnt, int out_cnt, Format format = FORMAT_NCHW, DataType data_type = DT_FLOAT, std::vector shape = {1, 1, 224, 224}); diff --git a/tests/st/framework/utils/builder/tensor_builder_utils.cc b/tests/framework/utils/builder/tensor_builder_utils.cc similarity index 100% rename from tests/st/framework/utils/builder/tensor_builder_utils.cc rename to tests/framework/utils/builder/tensor_builder_utils.cc diff --git a/tests/st/framework/utils/builder/tensor_builder_utils.h b/tests/framework/utils/builder/tensor_builder_utils.h similarity index 100% rename from tests/st/framework/utils/builder/tensor_builder_utils.h rename to tests/framework/utils/builder/tensor_builder_utils.h diff --git a/tests/st/CMakeLists.txt b/tests/st/CMakeLists.txt index 3b294681..9e05b03b 100644 --- a/tests/st/CMakeLists.txt +++ b/tests/st/CMakeLists.txt @@ -1,6 +1,2 @@ project(graphengine_st) - -include(cmake/graphengine.cmake) - -add_subdirectory(framework) add_subdirectory(testcase) \ No newline at end of file diff --git a/tests/st/framework/framework.cc b/tests/st/framework/framework.cc deleted file mode 100644 index 7484dd2e..00000000 --- a/tests/st/framework/framework.cc +++ /dev/null @@ -1,17 +0,0 @@ -/** - * Copyright 2021 Huawei Technologies Co., Ltd - - * 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. -*/ - -#include "framework.h" diff --git a/tests/st/testcase/CMakeLists.txt b/tests/st/testcase/CMakeLists.txt index 748e740f..9d1d5a0e 100644 --- a/tests/st/testcase/CMakeLists.txt +++ b/tests/st/testcase/CMakeLists.txt @@ -6,7 +6,7 @@ target_include_directories(graph_engine_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ) -set_target_properties(graph_engine_test PROPERTIES CXX_STANDARD 11) +set_target_properties(graph_engine_test PROPERTIES CXX_STANDARD 17) target_link_libraries(graph_engine_test PRIVATE gtest gtest_main framework) diff --git a/tests/st/testcase/test_framework_dummy.cc b/tests/st/testcase/test_framework_dummy.cc index af4050ab..951e6b2b 100644 --- a/tests/st/testcase/test_framework_dummy.cc +++ b/tests/st/testcase/test_framework_dummy.cc @@ -19,13 +19,13 @@ #include "external/ge/ge_api.h" #include "graph/debug/ge_attr_define.h" #include "framework/common/types.h" -#include "framework.h" -#include "framework/utils/builder/graph_builder_utils.h" +#include "builder/graph_builder_utils.h" #include "graph/operator_reg.h" #include "graph/operator.h" #define protected public #define private public #include "graph/utils/op_desc_utils.h" +#include "ge_graph_dsl/graph_dsl.h" #undef protected #undef private @@ -33,83 +33,83 @@ using namespace std; using namespace ge; namespace { /** data a = 2; -* for(int i =0; i<5; ++i){ -* a=a * 2; -* } -* return a; -* ----------------------------------------------| -* | const(5) exit const(1) | -* | \ / \ | -* data(i)--Enter--merge--less--loopcond--switch-----add-----nextiteration -* \________________\___/ -* ------\------------------------| -* | \ const(2) | -* | \ \ | -* data(a)--Enter--merge--switch------mul-----nextiteration -* \ -* exit -* \ -* netoutput -* -**/ -Graph BuildV1ControlFlowGraph(){ + * for(int i =0; i<5; ++i){ + * a=a * 2; + * } + * return a; + * ----------------------------------------------| + * | const(5) exit const(1) | + * | \ / \ | + * data(i)--Enter--merge--less--loopcond--switch-----add-----nextiteration + * \________________\___/ + * ------\------------------------| + * | \ const(2) | + * | \ \ | + * data(a)--Enter--merge--switch------mul-----nextiteration + * \ + * exit + * \ + * netoutput + * + **/ +Graph BuildV1ControlFlowGraph() { // build graph st::ComputeGraphBuilder graphBuilder("g1"); - auto data_i = graphBuilder.AddNode("data_i",DATA,1,1); - auto enter_i = graphBuilder.AddNode("enter_i",ENTER,1,1); + auto data_i = graphBuilder.AddNode("data_i", DATA, 1, 1); + auto enter_i = graphBuilder.AddNode("enter_i", ENTER, 1, 1); ge::AttrUtils::SetStr(enter_i->GetOpDesc(), ENTER_ATTR_FRAME_NAME, "1"); - auto merge_i = graphBuilder.AddNode("merge_i",MERGE,2,1); - auto const_5 = graphBuilder.AddNode("const_5",CONSTANT,0,1); - auto less = graphBuilder.AddNode("less",LESS,2,1); - auto loopcond = graphBuilder.AddNode("loopcond",LOOPCOND,1,1,FORMAT_NCHW,DT_BOOL); - auto switch_i = graphBuilder.AddNode("switch_i",SWITCH,2,2); - auto exit_i = graphBuilder.AddNode("switch_i",EXIT,1,1); - auto const_1 = graphBuilder.AddNode("const_1",CONSTANT,0,1); - auto add = graphBuilder.AddNode("add",ADD,2,1); - auto next_iteration_i = graphBuilder.AddNode("next_iteration_i",NEXTITERATION,1,1); + auto merge_i = graphBuilder.AddNode("merge_i", MERGE, 2, 1); + auto const_5 = graphBuilder.AddNode("const_5", CONSTANT, 0, 1); + auto less = graphBuilder.AddNode("less", LESS, 2, 1); + auto loopcond = graphBuilder.AddNode("loopcond", LOOPCOND, 1, 1, FORMAT_NCHW, DT_BOOL); + auto switch_i = graphBuilder.AddNode("switch_i", SWITCH, 2, 2); + auto exit_i = graphBuilder.AddNode("switch_i", EXIT, 1, 1); + auto const_1 = graphBuilder.AddNode("const_1", CONSTANT, 0, 1); + auto add = graphBuilder.AddNode("add", ADD, 2, 1); + auto next_iteration_i = graphBuilder.AddNode("next_iteration_i", NEXTITERATION, 1, 1); - auto data_a = graphBuilder.AddNode("data_a",DATA,1,1); - auto enter_a = graphBuilder.AddNode("enter_a",ENTER,1,1); + auto data_a = graphBuilder.AddNode("data_a", DATA, 1, 1); + auto enter_a = graphBuilder.AddNode("enter_a", ENTER, 1, 1); ge::AttrUtils::SetStr(enter_a->GetOpDesc(), ENTER_ATTR_FRAME_NAME, "1"); - auto merge_a = graphBuilder.AddNode("merge_a",MERGE,2,1); - auto switch_a = graphBuilder.AddNode("switch_a",SWITCH,2,2); - auto exit_a = graphBuilder.AddNode("exit_a",EXIT,1,1); - auto mul = graphBuilder.AddNode("mul",MUL,2,1); - auto const_2 = graphBuilder.AddNode("const_2",CONSTANT,0,1); - auto next_iteration_a = graphBuilder.AddNode("next_iteration_a",NEXTITERATION,1,1); - auto netoutput = graphBuilder.AddNode("netoutput",NETOUTPUT,2,2); + auto merge_a = graphBuilder.AddNode("merge_a", MERGE, 2, 1); + auto switch_a = graphBuilder.AddNode("switch_a", SWITCH, 2, 2); + auto exit_a = graphBuilder.AddNode("exit_a", EXIT, 1, 1); + auto mul = graphBuilder.AddNode("mul", MUL, 2, 1); + auto const_2 = graphBuilder.AddNode("const_2", CONSTANT, 0, 1); + auto next_iteration_a = graphBuilder.AddNode("next_iteration_a", NEXTITERATION, 1, 1); + auto netoutput = graphBuilder.AddNode("netoutput", NETOUTPUT, 2, 2); // i = i+1 - graphBuilder.AddDataEdge(data_i, 0, enter_i,0); - graphBuilder.AddDataEdge(enter_i, 0, merge_i,0); - graphBuilder.AddDataEdge(next_iteration_i, 0, merge_i,1); - graphBuilder.AddDataEdge(merge_i, 0, less,0); - graphBuilder.AddDataEdge(const_5, 0, less,1); - graphBuilder.AddDataEdge(less, 0, loopcond,0); - graphBuilder.AddDataEdge(loopcond, 0, switch_i,1); - graphBuilder.AddDataEdge(merge_i, 0, switch_i,0); - graphBuilder.AddDataEdge(switch_i, 0, exit_i,0); - graphBuilder.AddDataEdge(switch_i, 1, add,0); - graphBuilder.AddDataEdge(const_1, 0, add,1); - graphBuilder.AddDataEdge(add, 0, next_iteration_i,0); - graphBuilder.AddDataEdge(exit_i, 0, netoutput,1); + graphBuilder.AddDataEdge(data_i, 0, enter_i, 0); + graphBuilder.AddDataEdge(enter_i, 0, merge_i, 0); + graphBuilder.AddDataEdge(next_iteration_i, 0, merge_i, 1); + graphBuilder.AddDataEdge(merge_i, 0, less, 0); + graphBuilder.AddDataEdge(const_5, 0, less, 1); + graphBuilder.AddDataEdge(less, 0, loopcond, 0); + graphBuilder.AddDataEdge(loopcond, 0, switch_i, 1); + graphBuilder.AddDataEdge(merge_i, 0, switch_i, 0); + graphBuilder.AddDataEdge(switch_i, 0, exit_i, 0); + graphBuilder.AddDataEdge(switch_i, 1, add, 0); + graphBuilder.AddDataEdge(const_1, 0, add, 1); + graphBuilder.AddDataEdge(add, 0, next_iteration_i, 0); + graphBuilder.AddDataEdge(exit_i, 0, netoutput, 1); // a=a*2 - graphBuilder.AddDataEdge(data_a, 0, enter_a,0); - graphBuilder.AddDataEdge(enter_a, 0, merge_a,0); - graphBuilder.AddDataEdge(next_iteration_a, 0, merge_a,1); - graphBuilder.AddDataEdge(loopcond, 0, switch_a,1); - graphBuilder.AddDataEdge(merge_a, 0, switch_a,0); - graphBuilder.AddDataEdge(switch_a, 0, exit_a,0); - graphBuilder.AddDataEdge(switch_a, 1, mul,0); - graphBuilder.AddDataEdge(const_2, 0, mul,1); - graphBuilder.AddDataEdge(mul, 0, next_iteration_a,0); - graphBuilder.AddDataEdge(exit_a, 0, netoutput,0); + graphBuilder.AddDataEdge(data_a, 0, enter_a, 0); + graphBuilder.AddDataEdge(enter_a, 0, merge_a, 0); + graphBuilder.AddDataEdge(next_iteration_a, 0, merge_a, 1); + graphBuilder.AddDataEdge(loopcond, 0, switch_a, 1); + graphBuilder.AddDataEdge(merge_a, 0, switch_a, 0); + graphBuilder.AddDataEdge(switch_a, 0, exit_a, 0); + graphBuilder.AddDataEdge(switch_a, 1, mul, 0); + graphBuilder.AddDataEdge(const_2, 0, mul, 1); + graphBuilder.AddDataEdge(mul, 0, next_iteration_a, 0); + graphBuilder.AddDataEdge(exit_a, 0, netoutput, 0); // set const weight int64_t dims_size = 1; vector data_vec = {5}; for_each(data_vec.begin(), data_vec.end(), [&](int64_t &data) { dims_size *= data; }); vector data_value_vec(dims_size, 1); GeTensorDesc data_tensor_desc(GeShape(data_vec), FORMAT_NCHW, DT_INT32); - GeTensorPtr data_tensor = make_shared(data_tensor_desc, (uint8_t *)data_value_vec.data(), + GeTensorPtr data_tensor = make_shared(data_tensor_desc, (uint8_t *) data_value_vec.data(), data_value_vec.size() * sizeof(int32_t)); OpDescUtils::SetWeights(const_5->GetOpDesc(), data_tensor); OpDescUtils::SetWeights(const_2->GetOpDesc(), data_tensor); @@ -117,7 +117,7 @@ Graph BuildV1ControlFlowGraph(){ return graphBuilder.GetGraph(); } -} +} // namespace class FrameworkTest : public testing::Test { protected: void SetUp() { @@ -126,23 +126,19 @@ class FrameworkTest : public testing::Test { auto ret = ge::GEInitialize(options); EXPECT_EQ(ret, SUCCESS); } - void TearDown() { - } + void TearDown() {} }; /// data data /// \ / /// add TEST_F(FrameworkTest, test_framework_add) { - // build graph - st::ComputeGraphBuilder graphBuilder("g1"); - auto data1 = graphBuilder.AddNode("data1",DATA,1,1); - auto data2 = graphBuilder.AddNode("data2",DATA,1,1); - auto add = graphBuilder.AddNode("add",ADD,2,1); - graphBuilder.AddDataEdge(data1, 0, add,0); - graphBuilder.AddDataEdge(data2, 0, add,1); - Graph graph = graphBuilder.GetGraph(); + DEF_GRAPH(g1) { + CHAIN(NODE("data1", DATA)->NODE("add", ADD)); + CHAIN(NODE("data2", DATA)->NODE("add")); + }); + auto graph = ToGeGraph(g1); // new session & add graph map options; Session session(options); @@ -174,7 +170,7 @@ TEST_F(FrameworkTest, test_framework_add) { * \ * netoutput * -**/ + **/ TEST_F(FrameworkTest, test_framework_v1_control_flow) { // build graph Graph graph = BuildV1ControlFlowGraph();