hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

!1737 Feature: graph engine ST framework 

From: @hugo1
Reviewed-by: @sheng-nan,@wqtshg
Signed-off-by: @wqtshg
tags/v1.3.0
mindspore-ci-bot Gitee 4 years ago
parent
778ff7ac9f f3df7e869a
commit
4fa3a637d5
32 changed files with 1771 additions and 113 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +120
    -106
      CMakeLists.txt
  2. +27
    -1
      build.sh
  3. +2
    -1
      ge/ge_runtime/runtime_model.cc
  4. +1
    -1
      ge/ge_runtime/task/aicpu_task.cc
  5. +2
    -2
      ge/ge_runtime/task/hccl_task.cc
  6. +1
    -1
      ge/ge_runtime/task/label_goto_task.cc
  7. +1
    -1
      ge/ge_runtime/task/label_switch_task.cc
  8. +6
    -0
      tests/st/CMakeLists.txt
  9. +276
    -0
      tests/st/cmake/graphengine.cmake
  10. +77
    -0
      tests/st/framework/CMakeLists.txt
  11. +17
    -0
      tests/st/framework/framework.cc
  12. +22
    -0
      tests/st/framework/framework.h
  13. +33
    -0
      tests/st/framework/inc/st_types.h
  14. +70
    -0
      tests/st/framework/stub_engine/engine/stub_engine.cc
  15. +127
    -0
      tests/st/framework/stub_engine/engine/stub_engine.h
  16. +42
    -0
      tests/st/framework/stub_engine/ops_kernel_store/op/host_op.cc
  17. +36
    -0
      tests/st/framework/stub_engine/ops_kernel_store/op/host_op.h
  18. +45
    -0
      tests/st/framework/stub_engine/ops_kernel_store/op/op.h
  19. +51
    -0
      tests/st/framework/stub_engine/ops_kernel_store/op/stub_op_factory.cc
  20. +105
    -0
      tests/st/framework/stub_engine/ops_kernel_store/op/stub_op_factory.h
  21. +115
    -0
      tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.cc
  22. +51
    -0
      tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.h
  23. +75
    -0
      tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.cc
  24. +71
    -0
      tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.h
  25. +17
    -0
      tests/st/framework/utils/assertion/graph_assertion.cc
  26. +34
    -0
      tests/st/framework/utils/assertion/graph_assertion.h
  27. +48
    -0
      tests/st/framework/utils/builder/graph_builder_utils.cc
  28. +53
    -0
      tests/st/framework/utils/builder/graph_builder_utils.h
  29. +17
    -0
      tests/st/framework/utils/builder/tensor_builder_utils.cc
  30. +22
    -0
      tests/st/framework/utils/builder/tensor_builder_utils.h
  31. +15
    -0
      tests/st/testcase/CMakeLists.txt
  32. +192
    -0
      tests/st/testcase/test_framework_dummy.cc

+ 120
- 106
CMakeLists.txt View File

@@ -39,7 +39,7 @@ set(ATLAS_MS_RUNTIME_PATH ${ATLAS_RUNTIME_DIR} ${ATLAS_ACL_DIR} ${ATLAS_ATC_DIR}

option(ENABLE_OPEN_SRC "Enable graphengine compile in opensource." FALSE)

if (ENABLE_OPEN_SRC)
if (ENABLE_GE_COV OR ENABLE_GE_UT OR ENABLE_GE_ST)
set(HI_PYTHON python3)

include(cmake/external_libs/protobuf_shared.cmake)
@@ -51,118 +51,132 @@ if (ENABLE_OPEN_SRC)
include(cmake/external_libs/json.cmake)
include(cmake/FindModule.cmake)
include(cmake/intf_pub_linux.cmake)

# if D_LINK_PATH is set in environment variables, search libraries in given path
if(DEFINED ENV{D_LINK_PATH})
# D_LINK_PATH is set
set(GE_LIB_PATH $ENV{D_LINK_PATH})
set(GE_SYS_ARCH "")
if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64")
# x86 ubuntu
set(GE_SYS_ARCH "x86_64")
elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
# arm euleros
set(GE_SYS_ARCH "aarch64")
add_subdirectory(tests)
else ()
if (ENABLE_OPEN_SRC)
set(HI_PYTHON python3)

include(cmake/external_libs/protobuf_shared.cmake)
include(cmake/external_libs/protobuf_static.cmake)
include(cmake/external_libs/protoc.cmake)
include(cmake/external_libs/gflags.cmake)
include(cmake/external_libs/gtest.cmake)
include(cmake/external_libs/securec.cmake)
include(cmake/external_libs/json.cmake)
include(cmake/FindModule.cmake)
include(cmake/intf_pub_linux.cmake)

# if D_LINK_PATH is set in environment variables, search libraries in given path
if(DEFINED ENV{D_LINK_PATH})
# D_LINK_PATH is set
set(GE_LIB_PATH $ENV{D_LINK_PATH})
set(GE_SYS_ARCH "")
if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64")
# x86 ubuntu
set(GE_SYS_ARCH "x86_64")
elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
# arm euleros
set(GE_SYS_ARCH "aarch64")
else()
message(FATAL_ERROR "Running on a unsupported architecture: ${SYSTEM_TYPE}, build terminated")
endif()
set(GE_LIB_PATH ${GE_LIB_PATH}/${GE_SYS_ARCH})
set(STATIC_ACL_LIB ${GE_LIB_PATH})
find_module(slog libalog.so ${GE_LIB_PATH})
find_module(static_mmpa libmmpa.a ${GE_LIB_PATH})
find_module(msprofiler_ext libmsprofiler.a ${GE_LIB_PATH})
find_module(hccl libhccl.so ${GE_LIB_PATH})
find_module(adump_server libadump_server.a ${GE_LIB_PATH})
find_module(runtime libruntime.so ${GE_LIB_PATH})
find_module(runtime_compile libruntime_compile.so ${GE_LIB_PATH})
find_module(resource libresource.so ${GE_LIB_PATH})
find_module(ascend_hal_stub libascend_hal.so ${GE_LIB_PATH})
find_module(msprofiler_fwk_ext libmsprofiler_fwk.a ${GE_LIB_PATH})
#find_module(ascendcl_static libascendcl.a ${GE_LIB_PATH})
else()
message(FATAL_ERROR "Running on a unsupported architecture: ${SYSTEM_TYPE}, build terminated")
endif()
set(GE_LIB_PATH ${GE_LIB_PATH}/${GE_SYS_ARCH})
set(STATIC_ACL_LIB ${GE_LIB_PATH})
find_module(slog libalog.so ${GE_LIB_PATH})
find_module(static_mmpa libmmpa.a ${GE_LIB_PATH})
find_module(msprofiler_ext libmsprofiler.a ${GE_LIB_PATH})
find_module(hccl libhccl.so ${GE_LIB_PATH})
find_module(adump_server libadump_server.a ${GE_LIB_PATH})
find_module(runtime libruntime.so ${GE_LIB_PATH})
find_module(runtime_compile libruntime_compile.so ${GE_LIB_PATH})
find_module(resource libresource.so ${GE_LIB_PATH})
find_module(ascend_hal_stub libascend_hal.so ${GE_LIB_PATH})
find_module(msprofiler_fwk_ext libmsprofiler_fwk.a ${GE_LIB_PATH})
#find_module(ascendcl_static libascendcl.a ${GE_LIB_PATH})
elseif(ENABLE_GE_COV OR ENABLE_GE_UT)
add_subdirectory(tests)
else()
find_module(slog libalog.so ${ASCEND_ATC_DIR})
find_module(static_mmpa libmmpa.a ${ASCEND_ATC_DIR})
if(PLATFORM STREQUAL "train")
find_module(slog libalog.so ${ASCEND_ATC_DIR})
find_module(static_mmpa libmmpa.a ${ASCEND_ATC_DIR})
if(PLATFORM STREQUAL "train")
find_module(adump_server libadump_server.a ${ASCEND_RUNTIME_DIR})
find_module(runtime libruntime.so ${ASCEND_RUNTIME_DIR})
find_module(msprofiler_fwk_ext libmsprofiler_fwk.a ${ASCEND_RUNTIME_DIR})
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}/driver)
if(PRODUCT STREQUAL "flr3")
message(FATAL_ERROR "This platform is not supported in train mode, build terminated")
endif()
elseif(PLATFORM STREQUAL "inference")
find_module(adump_server libadump_server.a ${ASCEND_ACL_DIR})
find_module(runtime libruntime.so ${ASCEND_ACL_DIR})
find_module(runtime_compile libruntime_compile.so ${ASCEND_ATC_DIR})
find_module(msprofiler_ext libmsprofiler.a ${ASCEND_ACL_DIR})
if(PRODUCT STREQUAL "flr3")
elseif(PRODUCT STREQUAL "flr1")
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}/driver)
elseif(PRODUCT STREQUAL "flr2")
# flr2 ascend_hal_stub limsprof ?
else()
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR})
endif()
elseif(PLATFORM STREQUAL "all")
find_module(adump_server libadump_server.a ${ASCEND_RUNTIME_DIR})
find_module(runtime libruntime.so ${ASCEND_RUNTIME_DIR})
find_module(msprofiler_fwk_ext libmsprofiler_fwk.a ${ASCEND_RUNTIME_DIR})
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}/driver)
if(PRODUCT STREQUAL "flr3")
message(FATAL_ERROR "This platform is not supported in train mode, build terminated")
endif()
elseif(PLATFORM STREQUAL "inference")
find_module(adump_server libadump_server.a ${ASCEND_ACL_DIR})
find_module(runtime libruntime.so ${ASCEND_ACL_DIR})
find_module(runtime_compile libruntime_compile.so ${ASCEND_ATC_DIR})
find_module(msprofiler_fwk_ext libmsprofiler_fwk.a ${ASCEND_RUNTIME_DIR})
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR})
find_module(runtime_compile libruntime_compile.so ${ASCEND_ATC_DIR})
find_module(msprofiler_ext libmsprofiler.a ${ASCEND_ACL_DIR})
if(PRODUCT STREQUAL "flr3")
elseif(PRODUCT STREQUAL "flr1")
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}/driver)
elseif(PRODUCT STREQUAL "flr2")
# flr2 ascend_hal_stub limsprof ?
else()
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR})
message(STATUS "PLATFORM param is invalid, should be train or inference, you choose nothing!")
endif()
elseif(PLATFORM STREQUAL "all")
find_module(adump_server libadump_server.a ${ASCEND_RUNTIME_DIR})
find_module(runtime libruntime.so ${ASCEND_RUNTIME_DIR})
find_module(msprofiler_fwk_ext libmsprofiler_fwk.a ${ASCEND_RUNTIME_DIR})
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR})
find_module(runtime_compile libruntime_compile.so ${ASCEND_ATC_DIR})
find_module(msprofiler_ext libmsprofiler.a ${ASCEND_ACL_DIR})
else()
message(STATUS "PLATFORM param is invalid, should be train or inference, you choose nothing!")
endif()
endif()

set(METADEF_DIR ${CMAKE_CURRENT_LIST_DIR}/metadef)
set(PARSER_DIR ${CMAKE_CURRENT_LIST_DIR}/parser)
set(GE_DEPEND_DIR ${CMAKE_CURRENT_LIST_DIR}/..)

add_subdirectory(metadef)
add_subdirectory(parser)
#add_subdirectory(metadef/graph)
#add_subdirectory(metadef/register)
elseif (ENABLE_D OR ENABLE_ACL)
# compiling with MindSpore
include(cmake/external_libs/protobuf_static.cmake)
include(cmake/external_libs/protoc.cmake)
include(cmake/external_libs/securec.cmake)
include(cmake/external_libs/json.cmake)
include(cmake/FindModule.cmake)
include(cmake/intf_pub_linux.cmake)

# common libraries
find_module(slog libalog.so ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})
find_module(static_mmpa libmmpa.a ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})

if (ENABLE_D)
# training
find_module(runtime libruntime.so ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})
find_module(register libregister.so ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})
endif ()

set(METADEF_DIR ${CMAKE_CURRENT_LIST_DIR}/metadef)
add_subdirectory(metadef)
elseif(ENABLE_MS_TESTCASES)
include(cmake/external_libs/protobuf_static.cmake)
include(cmake/external_libs/protoc.cmake)
include(cmake/external_libs/securec.cmake)
include(cmake/FindModule.cmake)
include(cmake/intf_pub_linux.cmake)

# common libraries
find_module(slog libalog.so ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})
find_module(static_mmpa libmmpa.a ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})
set(METADEF_DIR ${CMAKE_CURRENT_LIST_DIR}/metadef)
set(PARSER_DIR ${CMAKE_CURRENT_LIST_DIR}/parser)
set(GE_DEPEND_DIR ${CMAKE_CURRENT_LIST_DIR}/..)

add_subdirectory(metadef)
add_subdirectory(parser)
#add_subdirectory(metadef/graph)
#add_subdirectory(metadef/register)
elseif (ENABLE_D OR ENABLE_ACL)
# compiling with MindSpore
include(cmake/external_libs/protobuf_static.cmake)
include(cmake/external_libs/protoc.cmake)
include(cmake/external_libs/securec.cmake)
include(cmake/external_libs/json.cmake)
include(cmake/FindModule.cmake)
include(cmake/intf_pub_linux.cmake)

# common libraries
find_module(slog libalog.so ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})
find_module(static_mmpa libmmpa.a ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})

if (ENABLE_D)
# training
find_module(runtime libruntime.so ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})
find_module(register libregister.so ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})
endif ()

set(METADEF_DIR ${CMAKE_CURRENT_LIST_DIR}/metadef)
add_subdirectory(metadef)
elseif(ENABLE_MS_TESTCASES)
include(cmake/external_libs/protobuf_static.cmake)
include(cmake/external_libs/protoc.cmake)
include(cmake/external_libs/securec.cmake)
include(cmake/FindModule.cmake)
include(cmake/intf_pub_linux.cmake)

# common libraries
find_module(slog libalog.so ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})
find_module(static_mmpa libmmpa.a ${ASCEND_MS_RUNTIME_PATH} ${ATLAS_MS_RUNTIME_PATH})

set(METADEF_DIR ${CMAKE_CURRENT_LIST_DIR}/metadef)
add_subdirectory(metadef)
else()
set(METADEF_DIR ${CMAKE_CURRENT_LIST_DIR}/../metadef)
set(PARSER_DIR ${CMAKE_CURRENT_LIST_DIR}/../parser)
set(GE_DEPEND_DIR ${CMAKE_CURRENT_LIST_DIR}/..)
endif()

set(METADEF_DIR ${CMAKE_CURRENT_LIST_DIR}/metadef)
add_subdirectory(metadef)
else()
set(METADEF_DIR ${CMAKE_CURRENT_LIST_DIR}/../metadef)
set(PARSER_DIR ${CMAKE_CURRENT_LIST_DIR}/../parser)
set(GE_DEPEND_DIR ${CMAKE_CURRENT_LIST_DIR}/..)
endif()
add_subdirectory(ge)

add_subdirectory(ge)
endif ()

+ 27
- 1
build.sh View File

@@ -177,6 +177,9 @@ build_graphengine()
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"
@@ -234,6 +237,29 @@ if [[ "X$ENABLE_GE_UT" = "Xon" || "X$ENABLE_GE_COV" = "Xon" ]]; then
genhtml coverage.info
fi

if [[ "X$ENABLE_GE_ST" = "Xon" ]]; then
#prepare engine & opskernel so
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}/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
#prepare st execution bin
cp ${BUILD_PATH}/tests/st/testcase/graph_engine_test ${OUTPUT_PATH}
#execute st testcase
RUN_TEST_CASE=${OUTPUT_PATH}/graph_engine_test && ${RUN_TEST_CASE}
if [[ "$?" -ne 0 ]]; then
echo "!!! ST FAILED, PLEASE CHECK YOUR CHANGES !!!"
echo -e "\033[31m${RUN_TEST_CASE}\033[0m"
exit 1;
fi
# remove plugin
rm -rf ${OUTPUT_PATH}/plugin
fi

# generate output package in tar form, including ut/st libraries/executables
generate_package()
{
@@ -337,7 +363,7 @@ generate_package()
fi
}

if [[ "X$ENABLE_GE_UT" = "Xoff" && "X$MINDSPORE_MODE" = "Xoff" ]]; then
if [[ "X$ENABLE_GE_UT" = "Xoff" && "X$ENABLE_GE_ST" = "Xoff" && "X$MINDSPORE_MODE" = "Xoff" ]]; then
generate_package
elif [ "X$MINDSPORE_MODE" = "Xon" ]
then


+ 2
- 1
ge/ge_runtime/runtime_model.cc View File

@@ -25,6 +25,7 @@
#include "framework/common/op/op_parser_util.h"
#include "graph/types.h"
#include "task/task_factory.h"
#include "ge/common/math/math_util.h"

namespace ge {
namespace model_runner {
@@ -500,7 +501,7 @@ bool RuntimeModel::InitConstantInfo(std::shared_ptr<DavinciModel> &davinci_model
}
uint64_t *buff = reinterpret_cast<uint64_t *>(const_cast<char *>(constant->weight_data.data()));
uint32_t head_len = kOffsetUnit * kStringHeadElems;
if (ge::CheckInt64Uint32MulOverflow(elem_num, head_len) != SUCCESS) {
if (CheckInt64Uint32MulOverflow(elem_num, head_len) != SUCCESS) {
GELOGE(FAILED, "Shape size is invalid");
return false;
}


+ 1
- 1
ge/ge_runtime/task/aicpu_task.cc View File

@@ -83,7 +83,7 @@ bool AicpuTask::Distribute() {
return false;
}

GELOGI("ext info size:", ext_size);
GELOGI("ext info size: %u", ext_size);
aicpu_param_head.extInfoLength = ext_size;
aicpu_param_head.extInfoAddr = reinterpret_cast<uintptr_t>(ext_info_);
}


+ 2
- 2
ge/ge_runtime/task/hccl_task.cc View File

@@ -130,7 +130,7 @@ bool HcclTask::SetSecondaryStream() {
Status ret;
std::lock_guard<std::mutex> lock(model_stream_mapping_mutex_);
if (model_stream_mapping_.find(rt_model_handle_) == model_stream_mapping_.end()) {
GELOGI("Need to create map for rt_model_handle_:%p with new mainstream %ld.", rt_model_handle_, master_stream_id);
GELOGI("Need to create map for rt_model_handle_:%p with new mainstream %u.", rt_model_handle_, master_stream_id);
ret = CreateStream(hccl_secondary_stream_num, master_stream_id);
if (!ret) {
GELOGE(RT_FAILED, "Create hccl stream failed.");
@@ -189,7 +189,7 @@ bool HcclTask::SetSecondaryStream() {
}
GELOGI("Initialize hccl secondary stream success, hccl_secondary_stream_num =%ld", hccl_secondary_stream_num);
} else {
GELOGI("Need to create secondary stream for %s with new mainstream %ld.", task_info_->op_name().c_str(),
GELOGI("Need to create secondary stream for %s with new mainstream %u.", task_info_->op_name().c_str(),
master_stream_id);
ret = CreateStream(hccl_secondary_stream_num, master_stream_id);
if (!ret) {


+ 1
- 1
ge/ge_runtime/task/label_goto_task.cc View File

@@ -72,7 +72,7 @@ bool LabelGotoTask::Distribute() {
return false;
}

rt_ret = rtLabelListCpy(label_list.data(), label_list.size(), label_info_, label_info_size);
rt_ret = rtLabelListCpy((void**)label_list.data(), label_list.size(), label_info_, label_info_size);
if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "Call rt api failed, ret: %#x", rt_ret);
return false;


+ 1
- 1
ge/ge_runtime/task/label_switch_task.cc View File

@@ -69,7 +69,7 @@ bool LabelSwitchTask::Distribute() {
return false;
}
label_list[i] = all_label_resource_[label_index];
GELOGI("Case %zu: label id %zu.", i, label_index);
GELOGI("Case %zu: label id %zu.", i, (size_t)label_index);
}

uint32_t label_info_size = sizeof(rtLabelDevInfo) * task_info_->label_size();


+ 6
- 0
tests/st/CMakeLists.txt View File

@@ -0,0 +1,6 @@
project(graphengine_st)

include(cmake/graphengine.cmake)

add_subdirectory(framework)
add_subdirectory(testcase)

+ 276
- 0
tests/st/cmake/graphengine.cmake View File

@@ -0,0 +1,276 @@
# ---- Test coverage ----

if (ENABLE_GE_COV)
set(COVERAGE_COMPILER_FLAGS "-g --coverage -fprofile-arcs -fPIC -O0 -ftest-coverage")
set(CMAKE_CXX_FLAGS "${COVERAGE_COMPILER_FLAGS}")
endif()

# ----metadef Proto generate ----
set(PROTO_LIST
"${GE_CODE_DIR}/metadef/proto/om.proto"
"${GE_CODE_DIR}/metadef/proto/ge_ir.proto"
"${GE_CODE_DIR}/metadef/proto/insert_op.proto"
"${GE_CODE_DIR}/metadef/proto/task.proto"
"${GE_CODE_DIR}/metadef/proto/dump_task.proto"
"${GE_CODE_DIR}/metadef/proto/fwk_adapter.proto"
"${GE_CODE_DIR}/metadef/proto/op_mapping.proto"
"${GE_CODE_DIR}/metadef/proto/ge_api.proto"
"${GE_CODE_DIR}/metadef/proto/optimizer_priority.proto"
"${GE_CODE_DIR}/metadef/proto/onnx/ge_onnx.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/attr_value.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/function.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/graph.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/node_def.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/op_def.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/resource_handle.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/tensor.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/tensor_shape.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/types.proto"
"${GE_CODE_DIR}/metadef/proto/tensorflow/versions.proto"
)

protobuf_generate(ge PROTO_SRCS PROTO_HDRS ${PROTO_LIST})

# ---- File glob by group ----

file(GLOB_RECURSE METADEF_SRCS CONFIGURE_DEPENDS
"${GE_CODE_DIR}/metadef/graph/*.cc"
"${GE_CODE_DIR}/metadef/register/*.cc"
"${GE_CODE_DIR}/metadef/register/*.cpp"
"${GE_CODE_DIR}/metadef/ops/*.cc"
"${GE_CODE_DIR}/metadef/third_party/transformer/src/*.cc"
)
file(GLOB_RECURSE METADEF_REGISTER_SRCS CONFIGURE_DEPENDS
"${GE_CODE_DIR}/metadef/register/*.cc"
"${GE_CODE_DIR}/metadef/register/*.cpp"
)

file(GLOB_RECURSE PARSER_SRCS CONFIGURE_DEPENDS
"${GE_CODE_DIR}/parser/parser/common/*.cc"
)

file(GLOB_RECURSE LOCAL_ENGINE_SRC CONFIGURE_DEPENDS
"${GE_CODE_DIR}/ge/ge_local_engine/*.cc"
)
list(REMOVE_ITEM LOCAL_ENGINE_SRC
"${GE_CODE_DIR}/ge/ge_local_engine/engine/host_cpu_engine.cc")


file(GLOB_RECURSE HOST_ENGINE_SRC CONFIGURE_DEPENDS
"${GE_CODE_DIR}/ge/host_cpu_engine/*.cc"
)

file(GLOB_RECURSE NN_ENGINE_SRC CONFIGURE_DEPENDS
"${GE_CODE_DIR}/ge/plugin/*.cc"
)

file(GLOB_RECURSE OFFLINE_SRC CONFIGURE_DEPENDS
"${GE_CODE_DIR}/ge/offline/*.cc"
)

file(GLOB_RECURSE GE_SRCS CONFIGURE_DEPENDS
"${GE_CODE_DIR}/ge/*.cc"
)
file(GLOB_RECURSE GE_SUB_ENGINE_SRCS CONFIGURE_DEPENDS
"${GE_CODE_DIR}/ge/ge_local_engine/engine/host_cpu_engine.cc"
)

list(REMOVE_ITEM GE_SRCS ${LOCAL_ENGINE_SRC} ${HOST_ENGINE_SRC} ${NN_ENGINE_SRC} ${OFFLINE_SRC})
list(APPEND GE_SRCS ${GE_SUB_ENGINE_SRCS})

list(APPEND INCLUDE_DIRECTORIES
"${CMAKE_CURRENT_SOURCE_DIR}"
"${GE_CODE_DIR}"
"${GE_CODE_DIR}/inc"
"${GE_CODE_DIR}/metadef/inc"
"${GE_CODE_DIR}/ge"
"${GE_CODE_DIR}/ge/inc"
"${GE_CODE_DIR}/ge/ir_build"
"${GE_CODE_DIR}/metadef"
"${GE_CODE_DIR}/metadef/graph"
"${GE_CODE_DIR}/inc/external"
"${GE_CODE_DIR}/inc/framework/common"
"${GE_CODE_DIR}/metadef/inc/external"
"${GE_CODE_DIR}/metadef/inc/external/graph"
"${GE_CODE_DIR}/metadef/inc/graph"
"${GE_CODE_DIR}/inc/framework"
"${GE_CODE_DIR}/metadef/inc/common"
"${GE_CODE_DIR}/metadef/third_party"
"${GE_CODE_DIR}/metadef/third_party/transformer/inc"
"${GE_CODE_DIR}/parser"
"${GE_CODE_DIR}/parser/parser"
"${GE_CODE_DIR}/third_party/fwkacllib/inc"
"${GE_CODE_DIR}/third_party/fwkacllib/inc/cce"
"${GE_CODE_DIR}/third_party/fwkacllib/inc/ops"
"${GE_CODE_DIR}/third_party/fwkacllib/inc/toolchain"
"${GE_CODE_DIR}/tests/ut/ge"
"${GE_CODE_DIR}/tests/ut/common"
"${CMAKE_BINARY_DIR}"
"${CMAKE_BINARY_DIR}/proto/ge"
"${CMAKE_BINARY_DIR}/proto/ge/proto"
)

list(APPEND STUB_LIBS
c_sec
slog_stub
cce_ge_stub
runtime_stub
profiler_stub
hccl_stub
error_manager_stub
ascend_protobuf
json
)

# ---- Target : metadef graph ----

add_library(metadef_graph SHARED ${METADEF_SRCS} ${PROTO_SRCS})

target_include_directories(metadef_graph
PUBLIC
"${INCLUDE_DIRECTORIES}"
)

target_compile_definitions(metadef_graph PRIVATE
google=ascend_private
FMK_SUPPORT_DUMP
)

target_compile_options(metadef_graph PRIVATE
-g --coverage -fprofile-arcs -ftest-coverage
-Werror=format
)

target_link_libraries(metadef_graph PUBLIC
$<BUILD_INTERFACE:intf_pub> ${STUB_LIBS}
mmpa -L${GE_CODE_DIR}/third_party/prebuild/x86_64 -lrt -ldl -lpthread -lgcov
)

set_target_properties(metadef_graph PROPERTIES CXX_STANDARD 11)

# ---- Target : Local engine ----

add_library(ge_local_engine SHARED ${LOCAL_ENGINE_SRC} ${METADEF_REGISTER_SRCS})

target_include_directories(ge_local_engine
PUBLIC
"${INCLUDE_DIRECTORIES}"
"${GE_CODE_DIR}/ge/ge_local_engine"
)

target_compile_definitions(ge_local_engine PRIVATE
google=ascend_private
)

target_compile_options(ge_local_engine PRIVATE
-g --coverage -fprofile-arcs -ftest-coverage
-Werror=format
)

target_link_libraries(ge_local_engine PUBLIC
$<BUILD_INTERFACE:intf_pub> ${STUB_LIBS}
metadef_graph
-lrt -ldl -lpthread -lgcov
)

set_target_properties(ge_local_engine PROPERTIES CXX_STANDARD 11)

# ---- Target : Host engine ----

add_library(host_cpu_engine SHARED ${HOST_ENGINE_SRC})

target_include_directories(host_cpu_engine
PUBLIC
"${INCLUDE_DIRECTORIES}"
"${GE_CODE_DIR}/ge/host_cpu_engine"
)

target_compile_definitions(host_cpu_engine PRIVATE
google=ascend_private
FMK_SUPPORT_DUMP
)

target_compile_options(host_cpu_engine PRIVATE
-g --coverage -fprofile-arcs -ftest-coverage
-Werror=format
)

target_link_libraries(host_cpu_engine PUBLIC
$<BUILD_INTERFACE:intf_pub> ${STUB_LIBS} metadef_graph -lrt -ldl -lpthread -lgcov
)

set_target_properties(host_cpu_engine PROPERTIES CXX_STANDARD 11)

# ---- Target : engine plugin----
#

add_library(nnengine SHARED ${NN_ENGINE_SRC})

target_include_directories(nnengine
PUBLIC
"${INCLUDE_DIRECTORIES}"
"${GE_CODE_DIR}/ge/plugin/engine"
)

target_compile_definitions(nnengine PRIVATE
google=ascend_private
)

target_compile_options(nnengine PRIVATE
-g --coverage -fprofile-arcs -ftest-coverage
-Werror=format
)

target_link_libraries(nnengine PUBLIC
$<BUILD_INTERFACE:intf_pub> ${STUB_LIBS} -lrt -ldl -lpthread -lgcov
)

set_target_properties(nnengine PROPERTIES CXX_STANDARD 11)

# Targe: engine_conf
add_custom_target(
engine_conf.json ALL
DEPENDS ${CMAKE_BINARY_DIR}/engine_conf.json
)
add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/engine_conf.json
COMMAND cp ${GE_CODE_DIR}/ge/engine_manager/engine_conf.json ${CMAKE_BINARY_DIR}/
)
# Targe: optimizer priority
add_custom_target(
optimizer_priority.pbtxt ALL
DEPENDS ${CMAKE_BINARY_DIR}/optimizer_priority.pbtxt
)
add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/optimizer_priority.pbtxt
COMMAND cp ${GE_CODE_DIR}/ge/opskernel_manager/optimizer_priority.pbtxt ${CMAKE_BINARY_DIR}/
)

# ---- Target : Graph engine ----

add_library(graphengine STATIC ${PARSER_SRCS} ${GE_SRCS})

target_include_directories(graphengine
PUBLIC
"${INCLUDE_DIRECTORIES}"
"${GE_CODE_DIR}/ge/host_cpu_engine"
)

target_compile_definitions(graphengine PRIVATE
google=ascend_private
FMK_SUPPORT_DUMP
)

target_compile_options(graphengine PRIVATE
-g --coverage -fprofile-arcs -ftest-coverage
-Werror=format
)

target_link_libraries(graphengine PUBLIC
$<BUILD_INTERFACE:intf_pub> ${STUB_LIBS}
metadef_graph
-lrt -ldl -lpthread -lgcov
)

set_target_properties(graphengine PROPERTIES CXX_STANDARD 11)
add_dependencies(graphengine host_cpu_engine ge_local_engine nnengine engine_conf.json optimizer_priority.pbtxt)

+ 77
- 0
tests/st/framework/CMakeLists.txt View File

@@ -0,0 +1,77 @@
list(APPEND INCLUDE_DIRECTORIES
"${CMAKE_CURRENT_SOURCE_DIR}"
"${GE_CODE_DIR}"
"${GE_CODE_DIR}/inc"
"${GE_CODE_DIR}/metadef/inc"
"${GE_CODE_DIR}/ge"
"${GE_CODE_DIR}/ge/inc"
"${GE_CODE_DIR}/ge/ir_build"
"${GE_CODE_DIR}/metadef"
"${GE_CODE_DIR}/metadef/graph"
"${GE_CODE_DIR}/inc/external"
"${GE_CODE_DIR}/inc/framework/common"
"${GE_CODE_DIR}/metadef/inc/external"
"${GE_CODE_DIR}/metadef/inc/external/graph"
"${GE_CODE_DIR}/metadef/inc/graph"
"${GE_CODE_DIR}/inc/framework"
"${GE_CODE_DIR}/metadef/inc/common"
"${GE_CODE_DIR}/metadef/third_party"
"${GE_CODE_DIR}/metadef/third_party/transformer/inc"
"${GE_CODE_DIR}/parser"
"${GE_CODE_DIR}/parser/parser"
"${GE_CODE_DIR}/third_party/fwkacllib/inc"
"${GE_CODE_DIR}/third_party/fwkacllib/inc/cce"
"${GE_CODE_DIR}/third_party/fwkacllib/inc/ops"
"${GE_CODE_DIR}/third_party/fwkacllib/inc/toolchain"
"${GE_CODE_DIR}/tests/ut/ge"
"${GE_CODE_DIR}/tests/ut/common"
"${CMAKE_BINARY_DIR}"
"${CMAKE_BINARY_DIR}/proto/ge"
"${CMAKE_BINARY_DIR}/proto/ge/proto"
)

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_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
google=ascend_private
FMK_SUPPORT_DUMP
)

target_compile_options(fe PRIVATE
-g --coverage -fprofile-arcs -ftest-coverage
-Werror=format
)

target_link_libraries(fe PUBLIC
$<BUILD_INTERFACE:intf_pub> ${STUB_LIBS} metadef_graph -lmmpa -L${GE_CODE_DIR}/third_party/prebuild/x86_64 -lrt -ldl -lpthread -lgcov
)

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)

+ 17
- 0
tests/st/framework/framework.cc View File

@@ -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.
*/

#include "framework.h"

+ 22
- 0
tests/st/framework/framework.h View File

@@ -0,0 +1,22 @@
/**
* 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_FRAMEWORK_H_
#define GRAPHENGINE_LLT_ST_FRAMEWORK_H_
#include <string>
#include "common/ge_inner_error_codes.h"

#endif // GRAPHENGINE_LLT_ST_FRAMEWORK_H_

+ 33
- 0
tests/st/framework/inc/st_types.h View File

@@ -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 GRAPHENGINE_ST_TYPES_H
#define GRAPHENGINE_ST_TYPES_H
#include <map>
namespace ge {
namespace st {
const std::string kAicoreLibName = "AiCoreLib";
const std::string kVectorLibName = "VectorLib";
const std::string kAicpuLibName = "AicpuLib";
const std::string kAicpuAscendLibName = "AicpuAscendLib";
const std::string kHcclLibName = "HcclLib";
const std::string kRTSLibName = "RTSLib";
const std::map<std::string, std::string> kStubEngine2KernelLib = {
{"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

+ 70
- 0
tests/st/framework/stub_engine/engine/stub_engine.cc View File

@@ -0,0 +1,70 @@
/**
* Copyright 2020 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 "stub_engine.h"
#include <map>
#include <memory>
#include <string>
#include <securec.h>
#include "framework/common/debug/ge_log.h"
#include "common/ge/ge_util.h"
#include "inc/st_types.h"

namespace ge {
namespace st {
StubEngine &StubEngine::Instance() {
static StubEngine instance;
return instance;
}

Status StubEngine::Initialize(const std::map<string, string> &options) {
for (const auto engine_2_lib : kStubEngine2KernelLib) {
auto ops_kernel_store = MakeShared<StubOpsKernelInfoStore>(engine_2_lib.second);
if (ops_kernel_store == nullptr) {
return FAILED;
}
ops_kernel_store_map_.insert(make_pair(engine_2_lib.second, ops_kernel_store));
}
return SUCCESS;
}

void StubEngine::GetOpsKernelInfoStores(std::map<std::string, OpsKernelInfoStorePtr> &ops_kernel_map) {
for (const auto name_2_ops_kernel_store : ops_kernel_store_map_) {
ops_kernel_map[name_2_ops_kernel_store.first] = name_2_ops_kernel_store.second;
}
}

void StubEngine::GetGraphOptimizerObjs(std::map<std::string, GraphOptimizerPtr> &) {
// no optimizer for host cpu engine
}

Status StubEngine::Finalize() { return SUCCESS; }
} // namespace st
} // namespace ge

ge::Status Initialize(const std::map<string, string> &options) {
return ge::st::StubEngine::Instance().Initialize(options);
}

void GetOpsKernelInfoStores(std::map<std::string, OpsKernelInfoStorePtr> &ops_kernel_map) {
ge::st::StubEngine::Instance().GetOpsKernelInfoStores(ops_kernel_map);
}

void GetGraphOptimizerObjs(std::map<std::string, GraphOptimizerPtr> &graph_optimizers) {
ge::st::StubEngine::Instance().GetGraphOptimizerObjs(graph_optimizers);
}

ge::Status Finalize() { return ge::st::StubEngine::Instance().Finalize(); }

+ 127
- 0
tests/st/framework/stub_engine/engine/stub_engine.h View File

@@ -0,0 +1,127 @@
/**
* Copyright 2020 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 GRAPH_ENGINE_LLT_STUB_ENGINE_H_
#define GRAPH_ENGINE_LLT_STUB_ENGINE_H_

#if defined(_MSC_VER)
#ifdef FUNC_VISIBILITY
#define GE_FUNC_VISIBILITY _declspec(dllexport)
#else
#define GE_FUNC_VISIBILITY
#endif
#else
#ifdef FUNC_VISIBILITY
#define GE_FUNC_VISIBILITY __attribute__((visibility("default")))
#else
#define GE_FUNC_VISIBILITY
#endif
#endif

#include <map>
#include <memory>
#include <string>
#include "inc/st_types.h"
#include "common/opskernel/ops_kernel_info_store.h"
#include "common/optimizer/graph_optimizer.h"
#include "stub_engine/ops_kernel_store/stub_ops_kernel_store.h"

using OpsKernelInfoStorePtr = std::shared_ptr<ge::OpsKernelInfoStore>;
using StubOpsKernelInfoStorePtr = std::shared_ptr<ge::st::StubOpsKernelInfoStore>;
using GraphOptimizerPtr = std::shared_ptr<ge::GraphOptimizer>;

namespace ge {
namespace st {
/**
* host cpu engine.
* Used for the ops which executes on host.
*/
class GE_FUNC_VISIBILITY StubEngine {
public:
/**
* get StubEngine instance.
* @return StubEngine instance.
*/
static StubEngine &Instance();

virtual ~StubEngine() = default;

/**
* When Ge start, GE will invoke this interface
* @return The status whether initialize successfully
*/
Status Initialize(const std::map<string, string> &options);

/**
* After the initialize, GE will invoke this interface
* to get the Ops kernel Store.
* @param ops_kernel_map The host cpu's ops kernel info
*/
void GetOpsKernelInfoStores(std::map<std::string, OpsKernelInfoStorePtr> &ops_kernel_map);

/**
* After the initialize, GE will invoke this interface
* to get the Graph Optimizer.
* @param graph_optimizers The host cpu's Graph Optimizer objs
*/
void GetGraphOptimizerObjs(std::map<std::string, GraphOptimizerPtr> &graph_optimizers);

/**
* When the graph finished, GE will invoke this interface
* @return The status whether initialize successfully
*/
Status Finalize();

StubEngine(const StubEngine &StubEngine) = delete;
StubEngine(const StubEngine &&StubEngine) = delete;
StubEngine &operator=(const StubEngine &StubEngine) = delete;
StubEngine &operator=(StubEngine &&StubEngine) = delete;

private:
StubEngine() = default;
map<string, OpsKernelInfoStorePtr> ops_kernel_store_map_;
};
} // namespace st
} // namespace ge

extern "C" {

/**
* When Ge start, GE will invoke this interface
* @return The status whether initialize successfully
*/
GE_FUNC_VISIBILITY ge::Status Initialize(const map<string, string> &options);

/**
* After the initialize, GE will invoke this interface to get the Ops kernel Store
* @param ops_kernel_map The host cpu's ops kernel info
*/
GE_FUNC_VISIBILITY void GetOpsKernelInfoStores(std::map<std::string, OpsKernelInfoStorePtr> &ops_kernel_map);

/**
* After the initialize, GE will invoke this interface to get the Graph Optimizer
* @param graph_optimizers The host cpu's Graph Optimizer objs
*/
GE_FUNC_VISIBILITY void GetGraphOptimizerObjs(std::map<std::string, GraphOptimizerPtr> &graph_optimizers);

/**
* When the graph finished, GE will invoke this interface
* @return The status whether initialize successfully
*/
GE_FUNC_VISIBILITY ge::Status Finalize();
}

#endif // GRAPH_ENGINE_LLT_STUB_ENGINE_H_

+ 42
- 0
tests/st/framework/stub_engine/ops_kernel_store/op/host_op.cc View File

@@ -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.
*/

#include "inc/st_types.h"
#include "stub_engine/ops_kernel_store/op/host_op.h"
#include "framework/common/util.h"
#include "stub_engine/ops_kernel_store/op/stub_op_factory.h"


namespace ge {
namespace st {
Status HostOp::Run() {
// no need to generate device task
return SUCCESS;
}
REGISTER_OP_CREATOR(Enter, RTSLib, HostOp);
REGISTER_OP_CREATOR(Merge, RTSLib, HostOp);
REGISTER_OP_CREATOR(Switch, RTSLib, HostOp);
REGISTER_OP_CREATOR(Less, AiCoreLib, HostOp);
REGISTER_OP_CREATOR(NextIteration, AiCoreLib, HostOp);
REGISTER_OP_CREATOR(LoopCond, RTSLib, HostOp);
REGISTER_OP_CREATOR(Exit, RTSLib, HostOp);
REGISTER_OP_CREATOR(StreamMerge, RTSLib, HostOp);
REGISTER_OP_CREATOR(StreamSwitch, RTSLib, HostOp);
REGISTER_OP_CREATOR(StreamActive, RTSLib, HostOp);
REGISTER_OP_CREATOR(Cast, AiCoreLib, HostOp);
REGISTER_OP_CREATOR(Transdata, AiCoreLib, HostOp);
} // namespace st
} // namespace ge

+ 36
- 0
tests/st/framework/stub_engine/ops_kernel_store/op/host_op.h View File

@@ -0,0 +1,36 @@
/**
* 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 GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_OP_HOST_OP_H_
#define GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_OP_HOST_OP_H_

#include "stub_engine/ops_kernel_store/op/op.h"

namespace ge {
namespace st {
class GE_FUNC_VISIBILITY HostOp : public Op {
public:
HostOp(const Node &node, RunContext &run_context) : Op(node, run_context) {}
~HostOp() override = default;
HostOp &operator=(const HostOp &op) = delete;
HostOp(const HostOp &op) = delete;

Status Run() override;
};
} // namespace st
} // namespace ge

#endif // GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_OP_HOST_OP_H_

+ 45
- 0
tests/st/framework/stub_engine/ops_kernel_store/op/op.h View File

@@ -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 GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_OP_OP_H_
#define GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_OP_OP_H_

#include <climits>
#include <string>
#include <vector>
#include "common/ge_inner_error_codes.h"
#include "common/opskernel/ops_kernel_info_types.h"
#include "graph/node.h"

namespace ge {
namespace st {
/**
* The base class for all op.
*/
class GE_FUNC_VISIBILITY Op {
public:
Op(const Node &node, RunContext &run_context) : run_context_(run_context), node_(node) {}
virtual ~Op() = default;
virtual Status Run() = 0;

protected:
const RunContext &run_context_;
const Node &node_;
};
} // namespace st
} // namespace ge

#endif // GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_OP_OP_H_

+ 51
- 0
tests/st/framework/stub_engine/ops_kernel_store/op/stub_op_factory.cc View File

@@ -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.
*/

#include "stub_op_factory.h"
#include "framework/common/debug/ge_log.h"
#include "common/ge_inner_error_codes.h"
#include "graph/op_desc.h"

namespace ge {
namespace st {
OpFactory &OpFactory::Instance() {
static OpFactory instance;
return instance;
}

std::shared_ptr<Op> OpFactory::CreateOp(const Node &node, RunContext &run_context) {
auto iter = op_creator_map_.find(node.GetType());
if (iter != op_creator_map_.end()) {
return iter->second(node, run_context);
}
GELOGE(FAILED, "Not supported OP, type = %s, name = %s", node.GetType().c_str(), node.GetName().c_str());
return nullptr;
}

void OpFactory::RegisterCreator(const std::string &type, const std::string &kernel_lib, const OP_CREATOR_FUNC &func) {
if (func == nullptr) {
GELOGW("Func is NULL.");
return;
}

if (all_store_ops_.find(kernel_lib) != all_store_ops_.end()) {
all_store_ops_[kernel_lib].emplace_back(type);
} else {
all_store_ops_[kernel_lib] = {type};
}
}
} // namespace st
} // namespace ge

+ 105
- 0
tests/st/framework/stub_engine/ops_kernel_store/op/stub_op_factory.h View File

@@ -0,0 +1,105 @@
/**
* 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 GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_OP_OP_FACTORY_H_
#define GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_OP_OP_FACTORY_H_

#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "common/ge/ge_util.h"
#include "stub_engine/ops_kernel_store/op/op.h"
#include "inc/st_types.h"

namespace ge {
namespace st {
using OP_CREATOR_FUNC = std::function<std::shared_ptr<Op>(const Node &, RunContext &)>;

/**
* manage all the op, support create op.
*/
class GE_FUNC_VISIBILITY OpFactory {
public:
static OpFactory &Instance();

/**
* @brief create Op.
* @param [in] node share ptr of node
* @param [in] run_context run context
* @return not nullptr success
* @return nullptr fail
*/
std::shared_ptr<Op> CreateOp(const Node &node, RunContext &run_context);

/**
* @brief Register Op create function.
* @param [in] type Op type
* @param [in] func Op create func
*/
void RegisterCreator(const std::string &type, const std::string &lib_name, const OP_CREATOR_FUNC &func);

const std::vector<std::string> &GetAllOps() const { return all_ops_; }

const std::vector<std::string> &GetAllOps(std::string lib_name) const {
auto iter = all_store_ops_.find(lib_name);
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(); }

OpFactory(const OpFactory &) = delete;
OpFactory &operator=(const OpFactory &) = delete;
OpFactory(OpFactory &&) = delete;
OpFactory &operator=(OpFactory &&) = delete;

private:
OpFactory() = default;
~OpFactory() = default;

// the op creator function map
std::map<std::string, OP_CREATOR_FUNC> op_creator_map_;
std::map<std::string, std::map<std::string, OP_CREATOR_FUNC>> lib_op_creator_map_;
std::vector<std::string> all_ops_;
std::map<std::string, vector<std::string>> all_store_ops_;
};

class GE_FUNC_VISIBILITY OpRegistrar {
public:
OpRegistrar(const std::string &type, const std::string &kernel_lib, const OP_CREATOR_FUNC &func) {
OpFactory::Instance().RegisterCreator(type, kernel_lib, func);
}
~OpRegistrar() = default;

OpRegistrar(const OpRegistrar &) = delete;
OpRegistrar &operator=(const OpRegistrar &) = delete;
OpRegistrar(OpRegistrar &&) = delete;
OpRegistrar &operator=(OpRegistrar &&) = delete;
};

#define REGISTER_OP_CREATOR(type, lib_name, clazz) \
std::shared_ptr<Op> Creator_##type##Op(const Node &node, RunContext &run_context) { \
return MakeShared<clazz>(node, run_context); \
} \
OpRegistrar g_##type##Op_creator(#type, #lib_name, Creator_##type##Op)
} // namespace st
} // namespace ge

#endif // GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_OP_OP_FACTORY_H_

+ 115
- 0
tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.cc View File

@@ -0,0 +1,115 @@
/**
* 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 "stub_ops_kernel_builder.h"
#include <memory>
#include "common/ge_inner_error_codes.h"
#include "ge/ge_api_types.h"
#include "graph/utils/node_utils.h"
#include "graph/utils/tensor_utils.h"
#include "graph/utils/type_utils.h"
#include <securec.h>
#include "framework/common/debug/ge_log.h"
#include "host_cpu_engine/common/constant/constant.h"
#include "register/ops_kernel_builder_registry.h"
#include "inc/st_types.h"

namespace ge {
namespace st {
REGISTER_OPS_KERNEL_BUILDER(kAicoreLibName, StubOpsKernelBuilder);
REGISTER_OPS_KERNEL_BUILDER(kVectorLibName, StubOpsKernelBuilder);
REGISTER_OPS_KERNEL_BUILDER(kAicpuLibName, StubOpsKernelBuilder);
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<std::string, std::string> &options) { return SUCCESS; }

Status StubOpsKernelBuilder::CalcOpRunningParam(Node &ge_node) {
OpDescPtr op_desc = ge_node.GetOpDesc();
if (op_desc == nullptr) {
GELOGE(FAILED, "[Get][OpDesc]CalcOpRunningParam failed, as op desc is null");
REPORT_INNER_ERROR("E19999", "GetOpDesc failed.");
return FAILED;
}

bool is_shape_unknown = false;
if (NodeUtils::GetNodeUnknownShapeStatus(ge_node, is_shape_unknown) == GRAPH_SUCCESS) {
if (is_shape_unknown) {
GELOGI("op:%s is unknown shape, does not need to calc output size.", ge_node.GetName().c_str());
return SUCCESS;
}
}

const string name = ge_node.GetName();
const string type = ge_node.GetType();
GELOGD("Calc op[%s:%s] running param, output size=%zu.", name.c_str(), type.c_str(), op_desc->GetOutputsSize());

for (size_t i = 0; i < op_desc->GetOutputsSize(); ++i) {
GeTensorDesc output_tensor = op_desc->GetOutputDesc(static_cast<uint32_t>(i));
Format format = output_tensor.GetFormat();
DataType data_type = output_tensor.GetDataType();

int64_t mem_size = 0;
// If mem size has been set, no need reset.
if ((TensorUtils::GetSize(output_tensor, mem_size) == GRAPH_SUCCESS) && (mem_size > 0)) {
GELOGD("Op[%s:%s] out[%zu] mem size has been set, no need calc again, format=%s, data_type=%s, mem_size=%ld.",
name.c_str(), type.c_str(), i, TypeUtils::FormatToSerialString(format).c_str(),
TypeUtils::DataTypeToSerialString(data_type).c_str(), mem_size);
continue;
}

int64_t output_mem_size = 0;
GeShape output_shape = output_tensor.GetShape();
if ((TensorUtils::CalcTensorMemSize(output_shape, format, data_type, output_mem_size) != GRAPH_SUCCESS) ||
(output_mem_size < 0)) {
GELOGE(FAILED,
"[Calc][TensorMemSize] fail 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());
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());
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,
output_mem_size, TypeUtils::FormatToSerialString(format).c_str(),
TypeUtils::DataTypeToSerialString(data_type).c_str());

TensorUtils::SetSize(output_tensor, output_mem_size);
if (op_desc->UpdateOutputDesc(static_cast<uint32_t>(i), output_tensor) != GRAPH_SUCCESS) {
GELOGE(FAILED, "[Update][OutputDesc] fail for op[%s:%s] out[%zu] desc , format=%s, data_type=%s.", name.c_str(),
type.c_str(), i, TypeUtils::FormatToSerialString(format).c_str(),
TypeUtils::DataTypeToSerialString(data_type).c_str());
REPORT_CALL_ERROR("E19999", "UpdateOutputDesc failed for op[%s:%s] out[%zu] desc , format=%s, data_type=%s.",
name.c_str(), type.c_str(), i, TypeUtils::FormatToSerialString(format).c_str(),
TypeUtils::DataTypeToSerialString(data_type).c_str());
return FAILED;
}
}

GELOGD("Calc op[%s:%s] running param success.", name.c_str(), type.c_str());
return SUCCESS;
}

Status StubOpsKernelBuilder::GenerateTask(const Node &node, RunContext &context, vector<domi::TaskDef> &tasks) {
// no need to generate device task
return SUCCESS;
}
} // namespace st
} // namespace ge

+ 51
- 0
tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_builder.h View File

@@ -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 GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_HOST_CPU_OPS_KERNEL_BUILDER_H_
#define GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_HOST_CPU_OPS_KERNEL_BUILDER_H_

#if defined(_MSC_VER)
#ifdef FUNC_VISIBILITY
#define GE_FUNC_VISIBILITY _declspec(dllexport)
#else
#define GE_FUNC_VISIBILITY
#endif
#else
#ifdef FUNC_VISIBILITY
#define GE_FUNC_VISIBILITY __attribute__((visibility("default")))
#else
#define GE_FUNC_VISIBILITY
#endif
#endif

#include "common/opskernel/ops_kernel_builder.h"

namespace ge {
namespace st {
class GE_FUNC_VISIBILITY StubOpsKernelBuilder : public OpsKernelBuilder {
public:
Status Initialize(const map<std::string, std::string> &options) override;

Status Finalize() override;

Status CalcOpRunningParam(Node &node) override;

Status GenerateTask(const Node &node, RunContext &context, std::vector<domi::TaskDef> &tasks) override;
};
} // namespace st
} // namespace ge

#endif // GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_HOST_CPU_OPS_KERNEL_BUILDER_H_

+ 75
- 0
tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.cc View File

@@ -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 "stub_ops_kernel_store.h"
#include <memory>
#include "ge/ge_api_types.h"
#include "framework/common/debug/ge_log.h"
#include "graph/utils/node_utils.h"
#include "graph/utils/tensor_utils.h"
#include "graph/utils/type_utils.h"
#include "op/stub_op_factory.h"

namespace ge {
namespace st {
using domi::TaskDef;
using std::map;
using std::string;
using std::vector;

Status StubOpsKernelInfoStore::Initialize(const map<string, string> &options) {
GELOGI("StubOpsKernelInfoStore init start.");
string engine_name;
for (const auto &engine_2_lib : kStubEngine2KernelLib) {
if (engine_2_lib.second == store_name_) {
engine_name = engine_2_lib.first;
}
}
if (engine_name.empty()) {
return FAILED;
}

OpInfo default_op_info = {.engine = engine_name,
.opKernelLib = store_name_,
.computeCost = 0,
.flagPartial = false,
.flagAsync = false,
.isAtomic = false};
// Init op_info_map_
auto all_ops_in_store = OpFactory::Instance().GetAllOps(store_name_);
for (auto &op : all_ops_in_store) {
op_info_map_[op] = default_op_info;
}

GELOGI("StubOpsKernelInfoStore inited success. op num=%zu", op_info_map_.size());
return SUCCESS;
}

Status StubOpsKernelInfoStore::Finalize() {
op_info_map_.clear();
return SUCCESS;
}

void StubOpsKernelInfoStore::GetAllOpsKernelInfo(map<string, OpInfo> &infos) const { infos = op_info_map_; }

bool StubOpsKernelInfoStore::CheckSupported(const OpDescPtr &op_desc, std::string &) const {
if (op_desc == nullptr) {
return false;
}
return op_info_map_.count(op_desc->GetType()) > 0;
}
} // namespace st
} // namespace ge

+ 71
- 0
tests/st/framework/stub_engine/ops_kernel_store/stub_ops_kernel_store.h View File

@@ -0,0 +1,71 @@
/**
* 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 GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_HOST_CPU_OPS_KERNEL_INFO_H_
#define GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_HOST_CPU_OPS_KERNEL_INFO_H_

#if defined(_MSC_VER)
#ifdef FUNC_VISIBILITY
#define GE_FUNC_VISIBILITY _declspec(dllexport)
#else
#define GE_FUNC_VISIBILITY
#endif
#else
#ifdef FUNC_VISIBILITY
#define GE_FUNC_VISIBILITY __attribute__((visibility("default")))
#else
#define GE_FUNC_VISIBILITY
#endif
#endif

#include <map>
#include <string>
#include <vector>

#include "common/opskernel/ops_kernel_info_store.h"

namespace ge {
namespace st {
/*const vector<std::string> kStubOpKernelLibNameVec = {
"AiCoreLib",
"AicpuLib",
"HcclLib",
"RTSLib"
};*/
class GE_FUNC_VISIBILITY StubOpsKernelInfoStore : public OpsKernelInfoStore {
public:
StubOpsKernelInfoStore(std::string store_name) : store_name_(store_name) {}
~StubOpsKernelInfoStore() override = default;
Status Initialize(const std::map<std::string, std::string> &options) override;
Status Finalize() override;
bool CheckSupported(const OpDescPtr &op_desc, std::string &reason) const override;
void GetAllOpsKernelInfo(std::map<std::string, ge::OpInfo> &infos) const override;
std::string GetOpsKernelStoreName() const { return store_name_; }

StubOpsKernelInfoStore(const StubOpsKernelInfoStore &ops_kernel_store) = delete;
StubOpsKernelInfoStore(const StubOpsKernelInfoStore &&ops_kernel_store) = delete;
StubOpsKernelInfoStore &operator=(const StubOpsKernelInfoStore &ops_kernel_store) = delete;
StubOpsKernelInfoStore &operator=(StubOpsKernelInfoStore &&ops_kernel_store) = delete;

private:
// store op name and OpInfo key-value pair
std::map<std::string, ge::OpInfo> op_info_map_;
std::string store_name_;
};
} // namespace st
} // namespace ge

#endif // GE_HOST_CPU_ENGINE_OPS_KERNEL_STORE_HOST_CPU_OPS_KERNEL_INFO_H_

+ 17
- 0
tests/st/framework/utils/assertion/graph_assertion.cc View File

@@ -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.
*/
#include "graph_assertion.h"

+ 34
- 0
tests/st/framework/utils/assertion/graph_assertion.h View File

@@ -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 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

+ 48
- 0
tests/st/framework/utils/builder/graph_builder_utils.cc View File

@@ -0,0 +1,48 @@
/**
* 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_builder_utils.h"
#include "inc/external/graph/operator.h"
#include "inc/external/graph/operator_factory.h"
#include "graph/utils/graph_utils.h"

namespace ge {
namespace st {
NodePtr ComputeGraphBuilder::AddNode(const std::string &name, const std::string &type, int in_cnt, int out_cnt,
Format format, DataType data_type, std::vector<int64_t> shape) {
auto tensor_desc = std::make_shared<GeTensorDesc>();
tensor_desc->SetShape(GeShape(std::move(shape)));
tensor_desc->SetFormat(format);
tensor_desc->SetDataType(data_type);

auto op_desc = std::make_shared<OpDesc>(name, type);
for (int i = 0; i < in_cnt; ++i) {
op_desc->AddInputDesc(tensor_desc->Clone());
}
for (int i = 0; i < out_cnt; ++i) {
op_desc->AddOutputDesc(tensor_desc->Clone());
}

return graph_->AddNode(op_desc);
}
void ComputeGraphBuilder::AddDataEdge(NodePtr &src_node, int src_idx, NodePtr &dst_node, int dst_idx) {
GraphUtils::AddEdge(src_node->GetOutDataAnchor(src_idx), dst_node->GetInDataAnchor(dst_idx));
}
void ComputeGraphBuilder::AddControlEdge(NodePtr &src_node, NodePtr &dst_node) {
GraphUtils::AddEdge(src_node->GetOutControlAnchor(), dst_node->GetInControlAnchor());
}
} // namespace st
} // namespace ge

+ 53
- 0
tests/st/framework/utils/builder/graph_builder_utils.h View File

@@ -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 GRAPHENGINE_LLT_ST_GRAPH_BUILDER_H
#define GRAPHENGINE_LLT_ST_GRAPH_BUILDER_H

#include <string>
#include <vector>

#include "graph/compute_graph.h"
#include "graph/utils/graph_utils.h"
#include "graph/graph.h"
#include "graph/node.h"

namespace ge {
namespace st {
class ComputeGraphBuilder {
public:
explicit ComputeGraphBuilder(const std::string &name) { graph_ = std::make_shared<ComputeGraph>(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<int64_t> shape = {1, 1, 224, 224});
void AddDataEdge(NodePtr &src_node, int src_idx, NodePtr &dst_node, int dst_idx);
void AddControlEdge(NodePtr &src_node, NodePtr &dst_node);
ComputeGraphPtr GetComputeGraph() {
graph_->TopologicalSorting();
return graph_;
}
Graph GetGraph() {
graph_->TopologicalSorting();
return GraphUtils::CreateGraphFromComputeGraph(graph_);
}

private:
ComputeGraphPtr graph_;
};
} // namespace st
} // namespace ge

#endif // GRAPHENGINE_LLT_ST_GRAPH_BUILDER_H

+ 17
- 0
tests/st/framework/utils/builder/tensor_builder_utils.cc View File

@@ -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.
*/
#include "tensor_builder_utils.h"

+ 22
- 0
tests/st/framework/utils/builder/tensor_builder_utils.h View File

@@ -0,0 +1,22 @@
/**
* 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_TENSOR_BUILDER_UTILS_H
#define GRAPHENGINE_LLT_ST_TENSOR_BUILDER_UTILS_H
class tensor_builder_utils {};
#endif // GRAPHENGINE_LLT_ST_TENSOR_BUILDER_UTILS_H

+ 15
- 0
tests/st/testcase/CMakeLists.txt View File

@@ -0,0 +1,15 @@
file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS "*.cc" "*.CC" "*.cpp" "*.CPP" "*.c++")

add_executable(graph_engine_test ${SOURCES})

target_include_directories(graph_engine_test
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
)

set_target_properties(graph_engine_test PROPERTIES CXX_STANDARD 11)

target_link_libraries(graph_engine_test PRIVATE gtest gtest_main framework)

include(CTest)
enable_testing()
add_test(NAME test COMMAND graph_engine_test)

+ 192
- 0
tests/st/testcase/test_framework_dummy.cc View File

@@ -0,0 +1,192 @@
/**
* 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 <map>
#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 "graph/operator_reg.h"
#include "graph/operator.h"
#define protected public
#define private public
#include "graph/utils/op_desc_utils.h"
#undef protected
#undef private

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(){
// 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);
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 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);
// 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);
// 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);
// set const weight
int64_t dims_size = 1;
vector<int64_t> data_vec = {5};
for_each(data_vec.begin(), data_vec.end(), [&](int64_t &data) { dims_size *= data; });
vector<int32_t> data_value_vec(dims_size, 1);
GeTensorDesc data_tensor_desc(GeShape(data_vec), FORMAT_NCHW, DT_INT32);
GeTensorPtr data_tensor = make_shared<GeTensor>(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);
OpDescUtils::SetWeights(const_1->GetOpDesc(), data_tensor);

return graphBuilder.GetGraph();
}
}
class FrameworkTest : public testing::Test {
protected:
void SetUp() {
// ge initialize
map<AscendString, AscendString> options;
auto ret = ge::GEInitialize(options);
EXPECT_EQ(ret, SUCCESS);
}
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();

// new session & add graph
map<AscendString, AscendString> options;
Session session(options);
auto ret = session.AddGraph(1, graph, options);
EXPECT_EQ(ret, SUCCESS);
// build input tensor
std::vector<InputTensorInfo> inputs;
// build_graph through session
ret = session.BuildGraph(1, inputs);
EXPECT_EQ(ret, SUCCESS);
}

/** 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
*
**/
TEST_F(FrameworkTest, test_framework_v1_control_flow) {
// build graph
Graph graph = BuildV1ControlFlowGraph();
// new session & add graph
map<AscendString, AscendString> options;
Session session(options);
auto ret = session.AddGraph(2, graph, options);
EXPECT_EQ(ret, SUCCESS);
// build input tensor
std::vector<InputTensorInfo> inputs;
// build_graph through session
ret = session.BuildGraph(2, inputs);
EXPECT_EQ(ret, SUCCESS);
// check result
}

Write Preview
Loading…
Cancel
Save