initial version

5 years ago · 5f763679fa
commit 5f763679fa
988 changed files with 315376 additions and 0 deletions
--- a/.clang-format
+++ b/.clang-format
@ -0,0 +1,152 @@
+---
+Language:        Cpp
+# BasedOnStyle:  Google
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Left
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     120
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 2
+Cpp11BracedListStyle: true
+DerivePointerAlignment: true
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+#  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^<ext/.*\.h>'
+    Priority:        2
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+  - Regex:           '^<.*'
+    Priority:        2
+  - Regex:           '.*'
+    Priority:        3
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Auto
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        2
+UseTab:          Never
+SortIncludes:    false
+...
+
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,29 @@
+# GraphEngine
+/build
+/output
+/prebuilts
+*.ir
+*.out
+
+# Dynamic libraries
+# *.so
+*.dylib
+
+# Static libraries
+*.la
+*.lai
+*.a
+*.lib
+
+# Protocol buffers
+*_pb2.py
+*.pb.h
+*.pb.cc
+
+# Object files
+*.o
+
+# Editor
+.vscode
+.idea/
+cmake-build-*
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -0,0 +1,134 @@
+# Copyright 2019-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.
+# ============================================================================
+
+cmake_minimum_required(VERSION 3.14)
+project (GraphEngine[CXX])
+set(CMAKE_CXX_STANDARD 14)
+
+set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR})
+set(GE_SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR})
+set(GE_PROTO_DIR ${GE_SOURCE_DIR}/src)
+
+if (NOT BUILD_PATH)
+    set(BUILD_PATH "${CMAKE_SOURCE_DIR}/build")
+endif()
+# architecture: aarch64 or x86_64
+message(STATUS "System architecture: ${CMAKE_HOST_SYSTEM_PROCESSOR}")
+# system: euleros or ubuntu
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    execute_process(
+            COMMAND bash "-c" "cat /etc/os-release | grep ^ID= | awk -F '=' '{print $2}'"
+            OUTPUT_VARIABLE SYSTEM_TYPE
+    )
+    MESSAGE(STATUS "System type: ${SYSTEM_TYPE}.")
+endif()
+
+# download json headers, rather than whole repository
+include(${GE_SOURCE_DIR}/cmake/ge_utils.cmake)
+include(${GE_SOURCE_DIR}/cmake/external_libs/json.cmake)
+include(${GE_SOURCE_DIR}/cmake/external_libs/eigen.cmake)
+include(${GE_SOURCE_DIR}/cmake/external_libs/gtest.cmake)
+include(${GE_SOURCE_DIR}/cmake/external_libs/protobuf.cmake)
+include(${GE_SOURCE_DIR}/cmake/external_libs/onnx.cmake)
+set(CMAKE_SKIP_RPATH TRUE)
+
+# for CPU/GPU mode, find c_sec and slog from local prebuild
+if(NOT ENABLE_D AND NOT GE_ONLY)
+    set(GE_PREBUILD_PATH ${GE_SOURCE_DIR}/third_party/prebuild/${CMAKE_HOST_SYSTEM_PROCESSOR})
+    find_library(c_sec libc_sec.so ${GE_PREBUILD_PATH})
+    find_library(slog libslog.so ${GE_PREBUILD_PATH})
+# if D_LINK_PATH is set in environment variables, search libraries in given path
+elseif(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})
+    find_library(c_sec libc_sec.so ${GE_LIB_PATH})
+    find_library(slog libslog.so ${GE_LIB_PATH})
+    find_library(mmpa libmmpa.so ${GE_LIB_PATH})
+    find_library(runtime libruntime.so ${GE_LIB_PATH})
+    find_library(msprof libmsprof.so ${GE_LIB_PATH})
+    find_library(register libregister.so ${GE_LIB_PATH})
+    find_library(hccl libhccl.so ${GE_LIB_PATH})
+    find_library(cce libcce.so ${GE_LIB_PATH})
+    find_library(resource libresource.so ${GE_LIB_PATH})
+else()
+    # Ascend mode
+    set(HIAI_INSTALLED_DIR /usr/local/HiAI)
+    set(HIAI_DRIVER_DIR ${HIAI_INSTALLED_DIR}/driver/lib64)
+    set(HIAI_RUNTIME_DIR ${HIAI_INSTALLED_DIR}/runtime/lib64)
+    find_library(c_sec libc_sec.so ${HIAI_DRIVER_DIR})
+    find_library(slog libslog.so ${HIAI_DRIVER_DIR})
+    find_library(mmpa libmmpa.so ${HIAI_DRIVER_DIR})
+
+    find_library(cce libcce.so ${HIAI_RUNTIME_DIR})
+    find_library(hccl libhccl.so ${HIAI_RUNTIME_DIR})
+    find_library(runtime libruntime.so ${HIAI_RUNTIME_DIR})
+    find_library(msprof libmsprof.so ${HIAI_RUNTIME_DIR})
+    find_library(register libregister.so ${HIAI_RUNTIME_DIR})
+    find_library(resource libresource.so ${HIAI_RUNTIME_DIR})
+endif()
+
+# add compile flags
+include(CheckCXXCompilerFlag)
+check_cxx_compiler_flag("-std=c++11" SUPPORT_CXX11)
+if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
+    message("Build in Debug mode")
+    set(CMAKE_C_FLAGS "-O0 -g -Wall -fstack-protector-all -Wl,-z,relro,-z,now,-z,noexecstack -pipe -fPIC ${CMAKE_C_FLAGS}")
+    set(CMAKE_CXX_FLAGS "-O0 -g -Wall -fstack-protector-all -Wl,-z,relro,-z,now,-z,noexecstack -pipe -fPIC ${CMAKE_CXX_FLAGS}")
+    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -rdynamic")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -rdynamic")
+    endif()
+else()
+    set(CMAKE_C_FLAGS "-O2 -Wall -fPIC -fstack-protector-all -Wl,-z,relro,-z,now,-z,noexecstack -pipe ${CMAKE_C_FLAGS}")
+    set(CMAKE_CXX_FLAGS "-O2 -Wall -fPIC -fstack-protector-all -Wl,-z,relro,-z,now,-z,noexecstack -pipe ${CMAKE_CXX_FLAGS}")
+endif ()
+
+# force __FILE__ to show relative path of file, from source directory, as cmake project makes __FILE__ absolute directory
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__FILE__='\"$(subst ${CMAKE_SOURCE_DIR}/,,$(abspath $<))\"' -Wno-builtin-macro-redefined")
+
+# compile libraries from following directories
+# libgraph is compiled in any situation
+add_subdirectory(${GE_SOURCE_DIR}/src/common/graph)
+if(ENABLE_D)
+    # if MindSpore compiles in D mode, compile the following libraries
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/common)
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/ge_runtime)
+elseif(GE_ONLY)
+    # standalone GraphEngine compiles all following libraries
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/common)
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/ge_runtime)
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/ge_local_engine)
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/graph/build/memory)
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/)
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/executor)
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/client)
+    add_subdirectory(${GE_SOURCE_DIR}/src/ge/plugin/engine)
+endif()
+
+if (ENABLE_GE_COV OR ENABLE_GE_UT OR ENABLE_GE_ST)
+    add_subdirectory(tests)
+endif()
+
--- a/201
+++ b/201
@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
--- a/2
+++ b/2
@ -0,0 +1,2 @@
+MindSpore GraphEngine
+Copyright 2019-2020 Huawei Technologies Co., Ltd
--- a/README.md
+++ b/README.md
@ -0,0 +1,107 @@
+  GraphEngine(GE) is a sub-module of MindSpore connecting the front end and devices which was designed by the researches and engineers within Huawei Technologies Co.,Ltd. GE is implemented via C++. It takes the graph of front end as its input and a series of graph operations are carried out to adapt the graph to a certain form which can be effectively operated on devices. GE is specifically designed for an efficient operation on Ascend Chips. GE is automatically called without any exposure to the users. GE mainly consists of two parts, i.e. GE API and GE Core. The architecture diagram of GE is illustrated as follows
+
+![GE_schema](docs/GE_Architecture.png)
+
+- GE API
+
+  GE API is the interface between GE Core and front end which controls the initialization and finalization of GE Core and Sessions. It also provides the interfaces for graph adding and running.
+
+- GE Core
+
+  GE Core acts as the core module of GE and is responsible for graph processing operations. It consist of six parts, i.e. graph preparation, graph partition, graph optimization, graph compilation, graph loading and graph execution. These six parts are performed in series and all together complete the complicated graph processing operations.
+
+  - Graph preparation
+
+    All the shapes of feature maps and variables in the graph are inferred in this stage for memory allocation later. Some aggregations of operators like allreduce are performed as well. Ascend Chips are heterogeneous chips including CPUs and vector calculation units, i.e. AICORE. Each operator in the graph is assigned to a certain operating cores according to the costs and supports. These two cores correspond to two different abstract engines in software. 
+
+  - Graph partition
+
+    The whole graph is split into several sub-graphs based on the assigned engine in previous stage. Certain operators are added to the sub-graphs as the marks for graph edges. Such a partition enables an efficient optimization, compilation in next stages.
+
+  - Graph optimization
+
+    Different optimizer interfaces are called due to different engines that each sub-graph belongs to. To thoroughly utilize the calculation ability of the CUBE module in AICORE, A novel data layout format for faster hardware fetch is applied and the transition between normal 4D to this special format is performed in this stage. Such an operation guarantees less data handling between RAMs and CUBEs. Certain combination of operators is fused into a single big operator to further reduce the computation costs. This fusion is carried out in this stage as well.
+
+  - Graph compilation
+
+    This stage can be divided into two parts, i.e. resources allocation and graph compilation. Memory allocation is completed considering memory reuse strategy in resources allocation stage. According to the graph information, the queue, event, stream resources are allocated. Each operator is compiled to a task bound to a certain stream. Tasks on the same stream are performed in series and task on different streams can be executed in parallel. This stream partition is completed in this stage.
+
+  - Graph loading
+
+    According to the engine information, the operators of graph are assigned to different engines and in this stage, the graph is loaded on the devices for running.
+
+  - Graph execution
+
+    The graph is executed on devices efficiently in this stage and the corresponding outputs are returned to the hosts. For efficiency consideration, a sink mode is provided where the graph is executed several times with the last output returned. Such a mode effectively reduces the data handling between devices and hosts.
+
+  In training or evaluating process, the aforementioned graph processing operations are carried out automatically. All in all, GE is a linked up module between MindSpore front end and Ascend Chips aiming to adapt the graph designed by users to a more efficient form that can be directly executed on Ascend Chips.
+
+- [Installation](#installation)
+- [Community](#community)
+- [Contributing](#contributing)
+- [Release Notes](#release-notes)
+- [License](#license)
+
+# Installation
+
+## Installing GraphEngine
+
+GE is automatically installed and compiled once you finish installing MindSpore. There are three dynamic link libraries corresponding to GE. 
+
+## Installing Using the Source Code
+
+You may also build GraphEngine from source.
+To build GraphEngine, please make sure that you have access to an [Ascend 910](https://e.huawei.com/se/products/cloud-computing-dc/atlas/ascend-910) environment as compiling environment, and make sure that following software requirements are fulfilled.
+ > - GCC >= 7.3.0
+ > - CMake >= 3.14.0
+ > - Autoconf >= 2.64
+ > - Libtool >= 2.4.6
+ > - Automake >= 1.15.1
+
+ as your compiling environment and  have GCC version >= 7.3.0 and CMake version >= 3.14.0 installed. It is necessary to be using an Ascend 910 environment to build GraphEngine.
+The output of building GraphEngine is a set of shared libraries which can be linked with MindSpore, they are not meant to be used independently.
+
+1. Download GraphEngine source code.
+
+GraphEngine source code is available on [Gitee](https://gitee.com/mindspore/graphengine):
+```shell
+git clone https://gitee.com/mindspore/graphengine.git
+cd graphengine
+```
+2. Run the following command in the root directory of the source code to compile GraphEngine:
+To build with default options, simply:
+```shell
+bash build.sh
+```
+ > - Before running the preceding command, ensure that the relevant paths have been added to the environment variable PATH.
+ > - In the build.sh script, the git clone command will be executed to obtain code from Gitee.com. Ensure that the network settings of Git are correct.
+ > - In the build.sh script, the default number of compilation threads is 8. If the compiler performance is poor, compilation errors may occur. You can add -j{Number of threads} in to bash command to reduce the number of threads. For example, `bash build.sh -j4`.
+
+3. Access the output directory of the source code, obtain the generated GraphEngine libraries which can be linked with MindSpore for further installation/testing.
+
+For more information on other options of building GraphEngine:
+```shell
+bash build.sh -h
+```
+
+If you wish to clean all outputs from last build and try again:
+```shell
+rm -rf build/ output/
+bash build.sh
+```
+
+## Community
+
+- [MindSpore Slack](https://join.slack.com/t/mindspore/shared_invite/enQtOTcwMTIxMDI3NjM0LTNkMWM2MzI5NjIyZWU5ZWQ5M2EwMTQ5MWNiYzMxOGM4OWFhZjI4M2E5OGI2YTg3ODU1ODE2Njg1MThiNWI3YmQ) - Ask questions and find answers.
+
+## Contributing
+
+Welcome contributions. See our [Contributor Wiki](https://gitee.com/mindspore/mindspore/blob/master/CONTRIBUTING.md) for more details.
+
+## Release Notes
+
+The release notes, see our [RELEASE](RELEASE.md).
+
+## License
+
+[Apache License 2.0](LICENSE)
--- a/RELEASE.md
+++ b/RELEASE.md
@ -0,0 +1,17 @@
+# Release 0.1.0-alpha
+
+This is the initial release of GraphEngine(GE) which was designed by the researchers and engineers in Huawei Technologies Co.,Ltd. GE is implemented via C++ and acts as a powerful backing force for MindSpore. GE is a linked up module between MindSpore front end and Ascend Chips.
+
+## Main features
+
+- GE API
+  - GE provides an unified interface with the front end including graph management interfaces i.e., graph loading and graph execution, and GE core initiallization and finalization interfaces.
+
+- Graph Processing
+  - Six parts of graph processing operations are executed within GE, i.e. graph preparation, graph partition, graph optimization, graph compilation, graph loading and graph execution.
+  - GE highly optimizes the graph defined by the front end to a form which can be effectively executed on Ascend Chips.
+  - GE supports several optimizations to reduce computation costs, e.g. operator fusion, parallel operation, data format transition.
+
+- Debugging
+  - GE supports data dump and graph dump for debugging.
+  - GE provides profiling tools to thoroughly analyze the speed performances.
--- a/460
+++ b/460
--- a/build.sh
+++ b/build.sh
@ -0,0 +1,172 @@
+#!/bin/bash
+# Copyright 2019-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.
+# ============================================================================
+
+set -e
+BASEPATH=$(cd "$(dirname $0)"; pwd)
+OUTPUT_PATH="${BASEPATH}/output"
+export BUILD_PATH="${BASEPATH}/build/"
+
+# print usage message
+usage()
+{
+  echo "Usage:"
+  echo "sh build.sh [-j[n]] [-A] [-h] [-v] [-s] [-t] [-u] [-c]"
+  echo ""
+  echo "Options:"
+  echo "    -h Print usage"
+  echo "    -u Only compile ut, not execute"
+  echo "    -s Build st"
+  echo "    -j[n] Set the number of threads used for building GraphEngine, default is 8"
+  echo "    -t Build and execute ut"
+  echo "    -c Build ut with coverage tag"
+  echo "    -v Display build command"
+  echo "to be continued ..."
+}
+
+# parse and set optionss
+checkopts()
+{
+  VERBOSE=""
+  THREAD_NUM=8
+  ENABLE_GE_UT_ONLY_COMPILE="off"
+  ENABLE_GE_UT="off"
+  ENABLE_GE_ST="off"
+  ENABLE_GE_COV="off"
+  GE_ONLY="on"
+  # Process the options
+  while getopts 'ustchj:vA' opt
+  do
+    OPTARG=$(echo ${OPTARG} | tr '[A-Z]' '[a-z]')
+    case "${opt}" in
+      u)
+        ENABLE_GE_UT_ONLY_COMPILE="on"
+        ENABLE_GE_UT="on"
+        ;;
+      s)
+        ENABLE_GE_ST="on"
+        ;;
+      t)
+	      ENABLE_GE_UT="on"
+	      ;;
+      c)
+        ENABLE_GE_COV="on"
+        ;;
+      h)
+        usage
+        exit 0
+        ;;
+      j)
+        THREAD_NUM=$OPTARG
+        ;;
+      v)
+        VERBOSE="VERBOSE=1"
+        ;;
+      A)
+        usage
+        ;;
+      *)
+        echo "Undefined option: ${opt}"
+        usage
+        exit 1
+    esac
+  done
+}
+checkopts "$@"
+
+mk_dir() {
+    local create_dir="$1"  # the target to make
+
+    mkdir -pv "${create_dir}"
+    echo "created ${create_dir}"
+}
+
+# GraphEngine build start
+echo "---------------- GraphEngine build start ----------------"
+
+# create build path
+build_graphengine()
+{
+  echo "create build directory and build GraphEngine";
+  mk_dir "${BUILD_PATH}/graphengine"
+  cd "${BUILD_PATH}/graphengine"
+  CMAKE_ARGS="-DBUILD_PATH=$BUILD_PATH -DGE_ONLY=$GE_ONLY"
+
+  if [[ "X$ENABLE_GE_COV" = "Xon" ]]; then
+    CMAKE_ARGS="${CMAKE_ARGS} -DENABLE_GE_COV=ON"
+  fi
+
+  if [[ "X$ENABLE_GE_UT" = "Xon" ]]; then
+    CMAKE_ARGS="${CMAKE_ARGS} -DENABLE_GE_UT=ON"
+  fi
+
+
+  if [[ "X$ENABLE_GE_ST" = "Xon" ]]; then
+    CMAKE_ARGS="${CMAKE_ARGS} -DENABLE_GE_ST=ON"
+  fi
+
+  echo "${CMAKE_ARGS}"
+  cmake ${CMAKE_ARGS} ../..
+  make ${VERBOSE} -j${THREAD_NUM}
+  echo "GraphEngine build success!"
+}
+g++ -v
+build_graphengine
+echo "---------------- GraphEngine build finished ----------------"
+mk_dir ${OUTPUT_PATH}
+cp -rf "${BUILD_PATH}/graphengine/"*.so "${OUTPUT_PATH}"
+rm -rf "${OUTPUT_PATH}/"libproto*
+rm -f ${OUTPUT_PATH}/libgmock*.so
+rm -f ${OUTPUT_PATH}/libgtest*.so
+rm -f ${OUTPUT_PATH}/lib*_stub.so
+
+chmod -R 750 ${OUTPUT_PATH}
+find ${OUTPUT_PATH} -name "*.so*" -print0 | xargs -0 chmod 500
+
+echo "---------------- GraphEngine output package generated ----------------"
+
+if [[ "X$ENABLE_GE_ST" = "Xon" ]]; then
+    cp ${BUILD_PATH}/graphengine/tests/st/st_resnet50_train ${OUTPUT_PATH}
+fi
+
+if [[ "X$ENABLE_GE_UT" = "Xon" || "X$ENABLE_GE_COV" = "Xon" ]]; then
+    cp ${BUILD_PATH}/graphengine/tests/ut/common/graph/ut_libgraph ${OUTPUT_PATH}
+    cp ${BUILD_PATH}/graphengine/tests/ut/ge/ut_libge_multiparts_utest ${OUTPUT_PATH}
+    cp ${BUILD_PATH}/graphengine/tests/ut/ge/ut_libge_distinct_load_utest ${OUTPUT_PATH}
+    cp ${BUILD_PATH}/graphengine/tests/ut/ge/ut_libge_others_utest ${OUTPUT_PATH}
+    cp ${BUILD_PATH}/graphengine/tests/ut/ge/ut_libge_kernel_utest ${OUTPUT_PATH}
+
+    if [[ "X${ENABLE_GE_UT_ONLY_COMPILE}" != "Xon" ]]; then
+        export LD_LIBRARY_PATH=${D_LINK_PATH}/x86_64/:${BUILD_PATH}/graphengine/:/usr/local/HiAI/driver/lib64:/usr/local/HiAI/runtime/lib64:${LD_LIBRARY_PATH}
+        echo ${LD_LIBRARY_PATH}
+        ${OUTPUT_PATH}/ut_libgraph &&
+        ${OUTPUT_PATH}/ut_libge_multiparts_utest &&
+        ${OUTPUT_PATH}/ut_libge_distinct_load_utest &&
+        ${OUTPUT_PATH}/ut_libge_others_utest &&
+        ${OUTPUT_PATH}/ut_libge_kernel_utest
+        if [[ "$?" -ne 0 ]]; then
+            echo "!!! UT FAILED, PLEASE CHECK YOUR CHANGES !!!"
+            exit 1;
+        fi
+    fi
+
+    if [[ "X$ENABLE_GE_COV" = "Xon" ]]; then
+        echo "Generating coverage statistics, please wait..."
+        cd ${BASEPATH}
+        rm -rf ${BASEPATH}/cov
+        mkdir ${BASEPATH}/cov
+        gcovr -r ./ --exclude 'third_party' --exclude 'build' --exclude 'tests' --exclude 'prebuild' --exclude 'inc' --print-summary --html --html-details -d -o cov/index.html
+    fi
+fi
--- a/cmake/external_libs/eigen.cmake
+++ b/cmake/external_libs/eigen.cmake
@ -0,0 +1,13 @@
+set(Eigen3_CXXFLAGS "-D_FORTIFY_SOURCE=2 -O2")
+set(Eigen3_CFLAGS "-D_FORTIFY_SOURCE=2 -O2")
+set(Eigen3_NS "ge_")
+graphengine_add_pkg(Eigen3
+        VER 3.3.7
+        URL https://gitlab.com/libeigen/eigen/-/archive/3.3.7/eigen-3.3.7.tar.gz
+        MD5 9e30f67e8531477de4117506fe44669b
+        CMAKE_OPTION -DBUILD_TESTING=OFF)
+
+find_package(Eigen3 3.3.7 REQUIRED ${GE_FIND_NO_DEFAULT_PATH})
+set_property(TARGET Eigen3::Eigen PROPERTY IMPORTED_GLOBAL TRUE)
+add_library(graphengine::eigen ALIAS Eigen3::Eigen)
+include_directories(${EIGEN3_INCLUDE_DIRS})
--- a/cmake/external_libs/gtest.cmake
+++ b/cmake/external_libs/gtest.cmake
@ -0,0 +1,16 @@
+set(ge_gtest_CXXFLAGS "-D_FORTIFY_SOURCE=2 -O2")
+set(ge_gtest_CFLAGS "-D_FORTIFY_SOURCE=2 -O2")
+
+graphengine_add_pkg(ge_gtest
+        VER 1.8.0
+        LIBS gtest gtest_main
+        URL https://github.com/google/googletest/archive/release-1.8.0.tar.gz
+        MD5 16877098823401d1bf2ed7891d7dce36
+        CMAKE_OPTION -DBUILD_TESTING=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DBUILD_SHARED_LIBS=ON
+        -DCMAKE_MACOSX_RPATH=TRUE -Dgtest_disable_pthreads=ON)
+
+add_library(graphengine::gtest ALIAS ge_gtest::gtest)
+add_library(graphengine::gtest_main ALIAS ge_gtest::gtest_main)
+include_directories(${ge_gtest_INC})
+file(COPY ${ge_gtest_INC}/../lib/libgtest.so DESTINATION ${CMAKE_SOURCE_DIR}/build/graphengine)
+file(COPY ${ge_gtest_INC}/../lib/libgtest_main.so DESTINATION ${CMAKE_SOURCE_DIR}/build/graphengine)
--- a/cmake/external_libs/json.cmake
+++ b/cmake/external_libs/json.cmake
@ -0,0 +1,9 @@
+set(nlohmann_json_CXXFLAGS "-D_FORTIFY_SOURCE=2 -O2")
+set(nlohmann_json_CFLAGS "-D_FORTIFY_SOURCE=2 -O2")
+graphengine_add_pkg(ge_nlohmann_json
+        VER 3.6.1
+        HEAD_ONLY ./
+        URL https://github.com/nlohmann/json/releases/download/v3.6.1/include.zip
+        MD5 0dc903888211db3a0f170304cd9f3a89)
+include_directories(${ge_nlohmann_json_INC})
+add_library(graphengine::json ALIAS ge_nlohmann_json)
--- a/cmake/external_libs/onnx.cmake
+++ b/cmake/external_libs/onnx.cmake
@ -0,0 +1,5 @@
+graphengine_add_pkg(onnx
+        VER 1.6.0
+        HEAD_ONLY ./
+        URL https://github.com/onnx/onnx/releases/download/v1.6.0/onnx-1.6.0.tar.gz
+        MD5 512f2779d6215d4a36f366b6b9acdf1e)
--- a/cmake/external_libs/protobuf.cmake
+++ b/cmake/external_libs/protobuf.cmake
@ -0,0 +1,57 @@
+if (NOT TARGET protobuf::libprotobuf)
+graphengine_add_pkg(protobuf
+        VER 3.8.0
+        HEAD_ONLY ./
+        URL https://github.com/protocolbuffers/protobuf/archive/v3.8.0.tar.gz
+        MD5 3d9e32700639618a4d2d342c99d4507a)
+set(protobuf_BUILD_TESTS OFF CACHE BOOL "Disahble protobuf test")
+set(protobuf_BUILD_SHARED_LIBS ON CACHE BOOL "Gen shared library")
+set(_ms_tmp_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+string(REPLACE " -Wall" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+string(REPLACE " -Werror" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+set(PROTOBUF_CMAKE_FILE "${protobuf_DIRPATH}/cmake/libprotobuf.cmake" )
+FILE(READ ${PROTOBUF_CMAKE_FILE} GE_MR_PROTOBUF_CMAKE)
+STRING(REPLACE "VERSION \${protobuf_VERSION}" "VERSION 19" GE_MR_PROTOBUF_CMAKE_V19 "${GE_MR_PROTOBUF_CMAKE}" )
+FILE(WRITE ${PROTOBUF_CMAKE_FILE} "${GE_MR_PROTOBUF_CMAKE_V19}")
+
+add_subdirectory(${protobuf_DIRPATH}/cmake ${protobuf_DIRPATH}/build)
+set(CMAKE_CXX_FLAGS ${_ms_tmp_CMAKE_CXX_FLAGS})
+endif()
+
+set(PROTOBUF_LIBRARY protobuf::libprotobuf)
+include_directories(${protobuf_DIRPATH}/src)
+add_library(ge_protobuf::protobuf ALIAS libprotobuf)
+
+function(ge_protobuf_generate comp c_var h_var)
+    if(NOT ARGN)
+        message(SEND_ERROR "Error: ge_protobuf_generate() called without any proto files")
+        return()
+    endif()
+
+    set(${c_var})
+    set(${h_var})
+
+    foreach(file ${ARGN})
+        get_filename_component(abs_file ${file} ABSOLUTE)
+        get_filename_component(file_name ${file} NAME_WE)
+        get_filename_component(file_dir ${abs_file} PATH)
+
+        list(APPEND ${c_var} "${CMAKE_BINARY_DIR}/proto/${comp}/proto/${file_name}.pb.cc")
+        list(APPEND ${h_var} "${CMAKE_BINARY_DIR}/proto/${comp}/proto/${file_name}.pb.h")
+
+        add_custom_command(
+                OUTPUT "${CMAKE_BINARY_DIR}/proto/${comp}/proto/${file_name}.pb.cc"
+                "${CMAKE_BINARY_DIR}/proto/${comp}/proto/${file_name}.pb.h"
+                WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+                COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/proto/${comp}/proto"
+                COMMAND protobuf::protoc -I${file_dir} --cpp_out=${CMAKE_BINARY_DIR}/proto/${comp}/proto ${abs_file}
+                DEPENDS protobuf::protoc ${abs_file}
+                COMMENT "Running C++ protocol buffer compiler on ${file}" VERBATIM )
+    endforeach()
+
+    set_source_files_properties(${${c_var}} ${${h_var}} PROPERTIES GENERATED TRUE)
+    set(${c_var} ${${c_var}} PARENT_SCOPE)
+    set(${h_var} ${${h_var}} PARENT_SCOPE)
+
+endfunction()
--- a/cmake/ge_utils.cmake
+++ b/cmake/ge_utils.cmake
--- a/docs/GE_Architecture.png
+++ b/docs/GE_Architecture.png
--- a/docs/README.md
+++ b/docs/README.md
@ -0,0 +1,3 @@
+# GraphEngine Documentation
+
+The GraphEngine documentation is in the [MindSpore Docs](https://gitee.com/mindspore/docs) repository.
--- a/inc/common/blocking_queue.h
+++ b/inc/common/blocking_queue.h
@ -0,0 +1,121 @@
+/**
+ * Copyright 2019-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 INC_COMMON_BLOCKING_QUEUE_H_
+#define INC_COMMON_BLOCKING_QUEUE_H_
+
+#include <stdint.h>
+
+#include <condition_variable>
+#include <list>
+#include <mutex>
+
+static const int kDefaultMaxQueueSize = 2048;
+
+template <typename T>
+class BlockingQueue {
+ public:
+  explicit BlockingQueue(uint32_t max_size = kDefaultMaxQueueSize) : max_size_(max_size), is_stoped_(false) {}
+
+  ~BlockingQueue() {}
+
+  bool Pop(T &item) {
+    std::unique_lock<std::mutex> lock(mutex_);
+
+    while (queue_.empty() && !is_stoped_) {
+      empty_cond_.wait(lock);
+    }
+
+    if (is_stoped_) {
+      return false;
+    }
+
+    item = queue_.front();
+    queue_.pop_front();
+
+    full_cond_.notify_one();
+
+    return true;
+  }
+
+  bool Push(const T &item, bool is_wait = true) {
+    std::unique_lock<std::mutex> lock(mutex_);
+
+    while (queue_.size() >= max_size_ && !is_stoped_) {
+      if (!is_wait) {
+        return false;
+      }
+      full_cond_.wait(lock);
+    }
+
+    if (is_stoped_) {
+      return false;
+    }
+
+    queue_.push_back(item);
+
+    empty_cond_.notify_one();
+
+    return true;
+  }
+
+  void Stop() {
+    {
+      std::unique_lock<std::mutex> lock(mutex_);
+      is_stoped_ = true;
+    }
+
+    full_cond_.notify_all();
+    empty_cond_.notify_all();
+  }
+
+  void Restart() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    is_stoped_ = false;
+  }
+
+  // if the queue stop , the function to release the unprocessed items will be call
+  std::list<T> GetRemainItems() {
+    std::unique_lock<std::mutex> lock(mutex_);
+
+    if (!is_stoped_) {
+      return std::list<T>();
+    }
+
+    return queue_;
+  }
+
+  bool IsFull() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    return queue_.size() >= max_size_;
+  }
+
+  void Clear() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    queue_.clear();
+  }
+
+ private:
+  std::list<T> queue_;
+  std::mutex mutex_;
+  std::condition_variable empty_cond_;
+  std::condition_variable full_cond_;
+  uint32_t max_size_;
+
+  bool is_stoped_;
+};
+
+#endif  // INC_COMMON_BLOCKING_QUEUE_H_
--- a/inc/common/dynamic_aipp.h
+++ b/inc/common/dynamic_aipp.h
@ -0,0 +1,104 @@
+/**
+ * Copyright 2019-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 INC_COMMON_DYNAMIC_AIPP_H_
+#define INC_COMMON_DYNAMIC_AIPP_H_
+
+#include <stdint.h>
+
+///
+/// @ingroup dnn
+/// @brief struct define of dynamic aipp batch parameter.
+///
+typedef struct tagAippDynamicBatchPara {
+  int8_t cropSwitch;     // crop switch
+  int8_t scfSwitch;      // resize switch
+  int8_t paddingSwitch;  // 0: unable padding
+                         // 1: padding config value,sfr_filling_hblank_ch0 ~  sfr_filling_hblank_ch2
+                         // 2: padding source picture data, single row/collumn copy
+                         // 3: padding source picture data, block copy
+                         // 4: padding source picture data, mirror copy
+  int8_t rotateSwitch;   // rotate switch，0: non-ratate，
+                         // 1: ratate 90° clockwise，2: ratate 180° clockwise，3: ratate 270° clockwise
+  int8_t reserve[4];
+  int32_t cropStartPosW;  // the start horizontal position of cropping
+  int32_t cropStartPosH;  // the start vertical position of cropping
+  int32_t cropSizeW;      // crop width
+  int32_t cropSizeH;      // crop height
+
+  int32_t scfInputSizeW;   // input width of scf
+  int32_t scfInputSizeH;   // input height of scf
+  int32_t scfOutputSizeW;  // output width of scf
+  int32_t scfOutputSizeH;  // output height of scf
+
+  int32_t paddingSizeTop;     // top padding size
+  int32_t paddingSizeBottom;  // bottom padding size
+  int32_t paddingSizeLeft;    // left padding size
+  int32_t paddingSizeRight;   // right padding size
+
+  int16_t dtcPixelMeanChn0;  // mean value of channel 0
+  int16_t dtcPixelMeanChn1;  // mean value of channel 1
+  int16_t dtcPixelMeanChn2;  // mean value of channel 2
+  int16_t dtcPixelMeanChn3;  // mean value of channel 3
+
+  uint16_t dtcPixelMinChn0;      // min value of channel 0
+  uint16_t dtcPixelMinChn1;      // min value of channel 1
+  uint16_t dtcPixelMinChn2;      // min value of channel 2
+  uint16_t dtcPixelMinChn3;      // min value of channel 3
+  uint16_t dtcPixelVarReciChn0;  // sfr_dtc_pixel_variance_reci_ch0
+  uint16_t dtcPixelVarReciChn1;  // sfr_dtc_pixel_variance_reci_ch1
+  uint16_t dtcPixelVarReciChn2;  // sfr_dtc_pixel_variance_reci_ch2
+  uint16_t dtcPixelVarReciChn3;  // sfr_dtc_pixel_variance_reci_ch3
+
+  int8_t reserve1[16];  // 32B assign, for ub copy
+} kAippDynamicBatchPara;
+
+///
+/// @ingroup dnn
+/// @brief struct definition of dynamic aipp parameter. lite:64+96*batchNum byte ; tiny:64+64*batchNum byte
+///
+typedef struct tagAippDynamicPara {
+  uint8_t inputFormat;    // input format：YUV420SP_U8/XRGB8888_U8/RGB888_U8
+  int8_t cscSwitch;       // csc switch
+  int8_t rbuvSwapSwitch;  // rb/ub swap switch
+  int8_t axSwapSwitch;    // RGBA->ARGB, YUVA->AYUV swap switch
+  int8_t batchNum;        // batch parameter number
+  int8_t reserve1[3];
+  int32_t srcImageSizeW;  // source image width
+  int32_t srcImageSizeH;  // source image height
+  int16_t cscMatrixR0C0;  // csc_matrix_r0_c0
+  int16_t cscMatrixR0C1;  // csc_matrix_r0_c1
+  int16_t cscMatrixR0C2;  // csc_matrix_r0_c2
+  int16_t cscMatrixR1C0;  // csc_matrix_r1_c0
+  int16_t cscMatrixR1C1;  // csc_matrix_r1_c1
+  int16_t cscMatrixR1C2;  // csc_matrix_r1_c2
+  int16_t cscMatrixR2C0;  // csc_matrix_r2_c0
+  int16_t cscMatrixR2C1;  // csc_matrix_r2_c1
+  int16_t cscMatrixR2C2;  // csc_matrix_r2_c2
+  int16_t reserve2[3];
+  uint8_t cscOutputBiasR0;  // output Bias for RGB to YUV, element of row 0, unsigned number
+  uint8_t cscOutputBiasR1;  // output Bias for RGB to YUV, element of row 1, unsigned number
+  uint8_t cscOutputBiasR2;  // output Bias for RGB to YUV, element of row 2, unsigned number
+  uint8_t cscInputBiasR0;   // input Bias for YUV to RGB, element of row 0, unsigned number
+  uint8_t cscInputBiasR1;   // input Bias for YUV to RGB, element of row 1, unsigned number
+  uint8_t cscInputBiasR2;   // input Bias for YUV to RGB, element of row 2, unsigned number
+  uint8_t reserve3[2];
+  int8_t reserve4[16];  // 32B assign, for ub copy
+
+  kAippDynamicBatchPara aippBatchPara;  // allow transfer several batch para.
+} kAippDynamicPara;
+
+#endif  // INC_COMMON_DYNAMIC_AIPP_H_
--- a/inc/common/npu_error_define.h
+++ b/inc/common/npu_error_define.h
@ -0,0 +1,94 @@
+/**
+ * Copyright 2019-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 INC_COMMON_NPU_ERROR_DEFINE_H_
+#define INC_COMMON_NPU_ERROR_DEFINE_H_
+
+typedef enum tagHiAiNpuLocal {
+  HIAI_HOST = 1,
+  HIAI_DEVICE = 2,
+} HiAiNpuLocal;
+
+typedef enum tagHiAiNpuCodeType {
+  ERROR_CODE = 1,
+  EXCEPTION_CODE = 2,
+} HiAiNpuCodeType;
+
+typedef enum tagHiAiNpuErrLevel {
+  NONE_LEVEL = 0,
+  SUGGESTION_LEVEL = 1,
+  NORMAL_LEVEL = 2,
+  SERIOUS_LEVEL = 3,
+  CRITICAL_ERROR = 4,
+} HiAiNpuErrLevel;
+
+typedef enum tagHiAiNpuModuleId {
+  HIAI_DRIVER = 1,
+  HIAI_CTRLCPU = 2,
+  HIAI_TS = 3,
+  HIAI_RUNTIME = 4,
+  HIAI_AICPU = 5,
+  HIAI_CCE = 6,
+  HIAI_TVM = 7,
+  HIAI_FRAMEWORK = 8,
+  HiAI_ENGINE = 9,
+  HIAI_DVPP = 10,
+  HIAI_AIPP = 11,
+  HIAI_LOWPOWER = 12,
+  HIAI_MDC = 13,
+  HIAI_COMPILE = 14,
+  HIAI_TOOLCHIAN = 15,
+  HIAI_ALG = 16,
+  HIAI_PROFILING = 17,
+  HIAI_HCCL = 18,
+  HIAI_SIMULATION = 19,
+  HIAI_BIOS = 20,
+  HIAI_SEC = 21,
+  HIAI_TINY = 22,
+  HIAI_DP = 23,
+} HiAiNpuModuleId;
+
+// bit 31-bit30 to be hiai local
+#define HIAI_NPULOCAL_MASK 0xC0000000
+#define SHIFT_LOCAL_MASK 30
+#define HIAI_NPULOCAL_VAL_MASK 0x3
+// bit 29 -bit28 to be hiai aicpu code type
+#define HIAI_CODE_TYPE_MASK 0x30000000
+#define SHIFT_CODE_MASK 28
+#define HIAI_CODE_TYPE_VAL_MASK 0x3
+// bit 27 -bit25 to be hiai error level
+#define HIAI_ERROR_LEVEL_MASK 0x0E000000
+#define SHIFT_ERROR_LVL_MASK 25
+#define HIAI_ERROR_LEVEL_VAL_MASK 0x7
+// bit 24 -bit17 to be hiai mod
+#define HIAI_MODE_ID_MASK 0x01FE0000
+#define SHIFT_MODE_MASK 17
+#define HIAI_MODE_ID_VAL_MASK 0xFF
+
+#define HIAI_NPU_LOC_BIT(a) \
+  (HIAI_NPULOCAL_MASK & ((unsigned int)((HiAiNpuLocal)(a)) & HIAI_NPULOCAL_VAL_MASK) << SHIFT_LOCAL_MASK)
+#define HIAI_NPU_CODE_TYPE_BIT(a) \
+  (HIAI_CODE_TYPE_MASK & ((unsigned int)((HiAiNpuCodeType)(a)) & HIAI_CODE_TYPE_VAL_MASK) << SHIFT_CODE_MASK)
+#define HIAI_NPU_ERR_LEV_BIT(a) \
+  (HIAI_ERROR_LEVEL_MASK & ((unsigned int)((HiAiNpuErrLevel)(a)) & HIAI_ERROR_LEVEL_VAL_MASK) << SHIFT_ERROR_LVL_MASK)
+#define HIAI_NPU_MOD_ID_BIT(a) \
+  (HIAI_MODE_ID_MASK & ((unsigned int)((HiAiNpuModuleId)(a)) & HIAI_MODE_ID_VAL_MASK) << SHIFT_MODE_MASK)
+
+#define HIAI_NPU_ERR_CODE_HEAD(npuLocal, codeType, errLevel, moduleId)                              \
+  (HIAI_NPU_LOC_BIT(npuLocal) + HIAI_NPU_CODE_TYPE_BIT(codeType) + HIAI_NPU_ERR_LEV_BIT(errLevel) + \
+   HIAI_NPU_MOD_ID_BIT(moduleId))
+
+#endif  // INC_COMMON_NPU_ERROR_DEFINE_H_
--- a/inc/common/opskernel/ge_task_info.h
+++ b/inc/common/opskernel/ge_task_info.h
@ -0,0 +1,55 @@
+/**
+ * Copyright 2019-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 INC_COMMON_OPSKERNEL_GE_TASK_INFO_H_
+#define INC_COMMON_OPSKERNEL_GE_TASK_INFO_H_
+
+#include <runtime/rt.h>
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+using std::string;
+namespace ge {
+// DAVINCI_TRAIN/DAVINCI_CLOUD is not needed when GETaskKernelHcclInfo needed
+struct GETaskKernelHcclInfo {
+  string hccl_type;
+  void *inputDataAddr;
+  void *outputDataAddr;
+  void *workSpaceAddr;
+  int32_t count;
+  int32_t dataType;
+  int32_t opType;
+  int64_t rootId;
+  uint64_t workSpaceMemSize;
+  std::vector<rtStream_t> hcclStreamList;
+};
+
+struct GETaskInfo {
+  uint32_t id;
+  uint16_t type;
+  uint32_t streamID;
+  void *stream;  // rtKernelLaunch input argument
+  void *event;
+  void *privateDef;
+  uint32_t privateDefLen;
+  void *opsKernelStorePtr;
+
+  GETaskKernelHcclInfo kernelHcclInfo;
+};
+}  // namespace ge
+#endif  // INC_COMMON_OPSKERNEL_GE_TASK_INFO_H_
--- a/inc/common/opskernel/ops_kernel_info_store.h
+++ b/inc/common/opskernel/ops_kernel_info_store.h
@ -0,0 +1,87 @@
+/**
+ * Copyright 2019-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 INC_COMMON_OPSKERNEL_OPS_KERNEL_INFO_STORE_H_
+#define INC_COMMON_OPSKERNEL_OPS_KERNEL_INFO_STORE_H_
+
+#include <iostream>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "./ge_task_info.h"
+#include "./ops_kernel_info_types.h"
+#include "cce/aicpu_engine_struct.h"
+#include "cce/fwk_adpt_struct.h"
+#include "common/ge_inner_error_codes.h"
+#include "graph/node.h"
+#include "proto/task.pb.h"
+
+using std::map;
+using std::string;
+using std::to_string;
+using std::vector;
+
+namespace ge {
+class OpDesc;
+
+class OpsKernelInfoStore {
+ public:
+  OpsKernelInfoStore() {}
+
+  virtual ~OpsKernelInfoStore() {}
+
+  // initialize opsKernelInfoStore
+  virtual Status Initialize(const map<string, string> &options) = 0;
+
+  // finalize opsKernelInfoStore
+  virtual Status Finalize() = 0;
+
+  virtual Status CreateSession(const std::map<std::string, std::string> &session_options) { return SUCCESS; }
+
+  virtual Status DestroySession(const std::map<std::string, std::string> &session_options) { return SUCCESS; }
+
+  // get all opsKernelInfo
+  virtual void GetAllOpsKernelInfo(map<string, OpInfo> &infos) const = 0;
+
+  // check whether opsKernelInfoStore is supported based on the operator attribute
+  virtual bool CheckSupported(const OpDescPtr &opDescPtr, std::string &un_supported_reason) const = 0;
+
+  virtual bool CheckAccuracySupported(const OpDescPtr &opDescPtr, std::string &un_supported_reason,
+                                      bool realQuery = false) const {
+    return CheckSupported(opDescPtr, un_supported_reason);
+  }
+
+  // requirement of memory allocation
+  virtual Status CalcOpRunningParam(Node &node) = 0;
+
+  // generate task for op
+  virtual Status GenerateTask(const Node &node, RunContext &context, std::vector<domi::TaskDef> &tasks) = 0;
+
+  // only call fe engine interface to compile single op
+  virtual Status CompileOp(vector<ge::NodePtr> &node_vec) { return SUCCESS; }
+
+  // load task for op
+  virtual Status LoadTask(GETaskInfo &task) { return SUCCESS; }
+
+  // only to call aicpu interface for generating task struct
+  virtual Status GenSingleOpRunTask(const NodePtr &node, STR_FWK_OP_KERNEL &task, string &task_info) { return SUCCESS; }
+
+  // only to call aicpu interface for generating task struct
+  virtual Status GenMemCopyTask(uint64_t count, STR_FWK_OP_KERNEL &task, string &task_info) { return SUCCESS; }
+};
+}  // namespace ge
+#endif  // INC_COMMON_OPSKERNEL_OPS_KERNEL_INFO_STORE_H_
--- a/inc/common/opskernel/ops_kernel_info_types.h
+++ b/inc/common/opskernel/ops_kernel_info_types.h
@ -0,0 +1,63 @@
+/**
+ * Copyright 2019-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 INC_COMMON_OPSKERNEL_OPS_KERNEL_INFO_TYPES_H_
+#define INC_COMMON_OPSKERNEL_OPS_KERNEL_INFO_TYPES_H_
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+#include "graph/buffer.h"
+#include "runtime/rt_model.h"
+
+using std::string;
+
+namespace ge {
+struct RunContext {
+  rtModel_t model;
+  rtStream_t stream;
+  uint64_t sessionId;
+  uint64_t dataMemSize;
+  uint8_t *dataMemBase;
+  uint64_t weightMemSize;
+  uint8_t *weightMemBase;
+  ge::Buffer weightsBuffer;
+  std::vector<rtStream_t> graphStreamList;  // all streams of graph which are sort by ge stream id(0,1,...)
+  std::vector<rtEvent_t> graphEventList;    // all events of graph which are sort by ge event id(0,1,...)
+};
+
+struct Task {
+  uint32_t id;
+  uint16_t type;
+  void *stream;
+  void *event;
+};
+
+struct OpInfo {
+  string engine;       // engine name
+  string opKernelLib;  // opsKernelStore name
+  int computeCost;     // compute cost
+  bool flagPartial;    // whether to support related shape
+  bool flagAsync;      // Whether to support asynchronous
+  bool isAtomic;       // whether to support atomic addr clean
+  string opFileName;   // op file name
+  string opFuncName;   // op function name
+};
+}  // namespace ge
+
+#endif  // INC_COMMON_OPSKERNEL_OPS_KERNEL_INFO_TYPES_H_
--- a/inc/common/optimizer/graph_optimizer.h
+++ b/inc/common/optimizer/graph_optimizer.h
@ -0,0 +1,61 @@
+/**
+ * Copyright 2019-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 INC_COMMON_OPTIMIZER_GRAPH_OPTIMIZER_H_
+#define INC_COMMON_OPTIMIZER_GRAPH_OPTIMIZER_H_
+
+#include <map>
+#include <string>
+
+#include "./graph_optimizer_types.h"
+#include "common/ge_inner_error_codes.h"
+#include "common/opskernel/ops_kernel_info_types.h"
+#include "graph/compute_graph.h"
+
+using std::map;
+using std::string;
+
+namespace ge {
+class GraphOptimizer {
+ public:
+  virtual ~GraphOptimizer() {}
+
+  // initialize graphOptimizer
+  virtual Status Initialize(const map<string, string> &options) = 0;
+
+  // close graphOptimizer
+  virtual Status Finalize() = 0;
+
+  // optimize original graph for FE quant optimization
+  virtual Status OptimizeGraphPrepare(ComputeGraph &graph) { return SUCCESS; }
+
+  // optimize original graph used in the graph preparation stage
+  virtual Status OptimizeOriginalGraph(ComputeGraph &graph) = 0;
+
+  // optimize fused graph
+  virtual Status OptimizeFusedGraph(ComputeGraph &graph) = 0;
+
+  // optimize the whole graph which will be used after graph merged
+  virtual Status OptimizeWholeGraph(ComputeGraph &graph) = 0;
+
+  // get attributes of graph optimizer
+  virtual Status GetAttributes(GraphOptimizerAttribute &attrs) const = 0;
+
+  // optimize streamed Graph
+  virtual Status OptimizeStreamGraph(ComputeGraph &graph, const RunContext &context) { return SUCCESS; }
+};
+}  // namespace ge
+#endif  // INC_COMMON_OPTIMIZER_GRAPH_OPTIMIZER_H_
--- a/inc/common/optimizer/graph_optimizer_types.h
+++ b/inc/common/optimizer/graph_optimizer_types.h
@ -0,0 +1,36 @@
+/**
+ * Copyright 2019-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 INC_COMMON_OPTIMIZER_GRAPH_OPTIMIZER_TYPES_H_
+#define INC_COMMON_OPTIMIZER_GRAPH_OPTIMIZER_TYPES_H_
+
+#include <stdint.h>
+#include <string>
+
+using std::string;
+namespace ge {
+enum OPTIMIZER_SCOPE {
+  UNIT = 0,
+  ENGINE,
+};
+
+struct GraphOptimizerAttribute {
+  string engineName;
+  OPTIMIZER_SCOPE scope;
+};
+}  // namespace ge
+
+#endif  // INC_COMMON_OPTIMIZER_GRAPH_OPTIMIZER_TYPES_H_
--- a/Show More
+++ b/Show More