ARMNN_MAIN_HEADER_PATH := $(LOCAL_PATH)/src
ARMNN_SOURCE_HEADER_PATH := $(LOCAL_PATH)/src/armnn
ARMNN_SOURCE_UTILS_HEADER_PATH := $(LOCAL_PATH)/src/armnnUtils
+ARMNN_BACKENDS_HEADER_PATH := $(LOCAL_PATH)/src/backends
# find the common.mk and backend.mk files in the backend source folders
-ARMNN_BACKEND_COMMON_MAKEFILE_LOCAL_PATHS := $(wildcard $(LOCAL_PATH)/src/backends/*/common.mk) \
- $(LOCAL_PATH)/src/backends/common.mk
+ARMNN_BACKEND_COMMON_MAKEFILE_LOCAL_PATHS := $(wildcard $(LOCAL_PATH)/src/backends/*/common.mk)
ARMNN_BACKEND_COMMON_MAKEFILE_PATHS := $(subst $(LOCAL_PATH),,$(ARMNN_BACKEND_COMMON_MAKEFILE_LOCAL_PATHS))
ARMNN_BACKEND_COMMON_MAKEFILE_DIRS := $(subst /common.mk,,$(ARMNN_BACKEND_COMMON_MAKEFILE_PATHS))
LOCAL_EXPORT_C_INCLUDES := \
$(ARMNN_MAIN_HEADER_PATH) \
$(ARMNN_SOURCE_HEADER_PATH) \
- $(ARMNN_SOURCE_UTILS_HEADER_PATH)
+ $(ARMNN_SOURCE_UTILS_HEADER_PATH) \
+ $(ARMNN_BACKENDS_HEADER_PATH)
LOCAL_C_INCLUDES := \
$(OPENCL_HEADER_PATH) \
$(ARMNN_HEADER_PATH) \
$(ARMNN_MAIN_HEADER_PATH) \
$(ARMNN_SOURCE_HEADER_PATH) \
- $(ARMNN_SOURCE_UTILS_HEADER_PATH)
+ $(ARMNN_SOURCE_UTILS_HEADER_PATH) \
+ $(ARMNN_BACKENDS_HEADER_PATH)
LOCAL_SRC_FILES := \
$(ARMNN_BACKEND_SOURCES) \
$(ARMNN_HEADER_PATH) \
$(ARMNN_MAIN_HEADER_PATH) \
$(ARMNN_SOURCE_HEADER_PATH) \
- $(ARMNN_SOURCE_UTILS_HEADER_PATH)
+ $(ARMNN_SOURCE_UTILS_HEADER_PATH) \
+ $(ARMNN_BACKENDS_HEADER_PATH)
LOCAL_CFLAGS := \
-std=c++14 \
add_library_ex(armnn SHARED ${armnn_sources})
-target_include_directories(armnn PRIVATE src)
target_include_directories(armnn PRIVATE src/armnn)
target_include_directories(armnn PRIVATE src/armnnUtils)
+target_include_directories(armnn PRIVATE src/backends)
target_link_libraries(armnn armnnUtils)
endforeach()
add_executable(UnitTests ${unittest_sources})
- target_include_directories(UnitTests PRIVATE src)
target_include_directories(UnitTests PRIVATE src/armnn)
target_include_directories(UnitTests PRIVATE src/armnnUtils)
+ target_include_directories(UnitTests PRIVATE src/backends)
if(VALGRIND_FOUND)
if(HEAP_PROFILING OR LEAK_CHECKING)
#include "Layer.hpp"
#include "Graph.hpp"
-#include <backends/WorkloadData.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <boost/cast.hpp>
#include <boost/format.hpp>
#include "LayerFwd.hpp"
-#include <backends/OutputHandler.hpp>
-#include <backends/WorkloadDataCollector.hpp>
-#include <backends/WorkloadInfo.hpp>
+#include <backendsCommon/OutputHandler.hpp>
+#include <backendsCommon/WorkloadDataCollector.hpp>
+#include <backendsCommon/WorkloadInfo.hpp>
#include "InternalTypes.hpp"
#include "SerializeLayerParameters.hpp"
#include <armnn/LayerSupport.hpp>
#include <armnn/Optional.hpp>
-#include <backends/LayerSupportRegistry.hpp>
+#include <backendsCommon/LayerSupportRegistry.hpp>
#include <boost/assert.hpp>
#include "Profiling.hpp"
#include "HeapProfiling.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/BackendRegistry.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/BackendRegistry.hpp>
#include <boost/polymorphic_cast.hpp>
#include <boost/assert.hpp>
#include "LayerFwd.hpp"
#include "Profiling.hpp"
-#include <backends/IBackendInternal.hpp>
-#include <backends/Workload.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include <mutex>
#include <unordered_map>
#include "Optimizer.hpp"
#include "optimizations/All.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/Utils.hpp>
#include "Runtime.hpp"
#include <armnn/Version.hpp>
-#include <backends/BackendRegistry.hpp>
-#include <backends/BackendContextRegistry.hpp>
+#include <backendsCommon/BackendRegistry.hpp>
+#include <backendsCommon/BackendContextRegistry.hpp>
#include <iostream>
#include <armnn/IRuntime.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/BackendId.hpp>
-#include <backends/IBackendContext.hpp>
+#include <backendsCommon/IBackendContext.hpp>
#include <mutex>
#include <unordered_map>
#pragma once
#include "armnn/Types.hpp"
-#include "armnnUtils/Half.hpp"
+#include "Half.hpp"
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "MeanLayer.hpp"
#include "LayerCloneBase.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include <cstring>
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
-#include <backends/MemCopyWorkload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+#include <backendsCommon/MemCopyWorkload.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include <queue>
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "PadLayer.hpp"
#include "LayerCloneBase.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include <cstring>
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include <Permute.hpp>
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include <numeric>
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
#include "Optimization.hpp"
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <FloatingPointConverter.hpp>
-#include <armnnUtils/Half.hpp>
+#include <Half.hpp>
namespace armnn
{
#include <boost/cast.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/WorkloadFactory.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <Graph.hpp>
}
/////////////////////////////////////////////////////////////////////////////////////////////
-// The following functions are called by backends/test/CreateWorkload*.cpp
+// The following functions are called by backendsCommon/test/CreateWorkload*.cpp
// They build very simple graphs, and then create a workload.
// Some checks are performed on the workload to ensure parameters have been passed correctly.
// They return the created workloads so that backend-specific checks can be performed.
#include <armnn/IRuntime.hpp>
#include <armnn/INetwork.hpp>
-#include <backends/test/QuantizeHelper.hpp>
+#include <backendsCommon/test/QuantizeHelper.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/test/unit_test.hpp>
//
#include "FloatingPointConverter.hpp"
-#include <armnnUtils/Half.hpp>
+#include <Half.hpp>
#include <malloc.h>
#include <iostream>
#include <Graph.hpp>
#include <Layer.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
/// Checks that first comes before second in the order.
//
#pragma once
-#include <armnn/Graph.hpp>
+#include <Graph.hpp>
#include <string>
#include "GraphUtils.hpp"
#include <armnn/ArmNN.hpp>
-#include <armnn/Network.hpp>
+#include <Network.hpp>
#include <boost/test/unit_test.hpp>
#include <armnn/ArmNN.hpp>
#include <Graph.hpp>
#include <Optimizer.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <FloatingPointConverter.hpp>
namespace
#include <armnn/Descriptors.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/INetwork.hpp>
-#include <armnn/Runtime.hpp>
+#include <Runtime.hpp>
#include <armnn/TypesUtils.hpp>
-#include <armnnUtils/HeapProfiling.hpp>
-#include <armnnUtils/LeakChecking.hpp>
+#include <HeapProfiling.hpp>
+#include <LeakChecking.hpp>
#ifdef WITH_VALGRIND
#include <valgrind/memcheck.h>
//
#pragma once
-#include <armnn/Runtime.hpp>
+#include <Runtime.hpp>
namespace armnn
{
#include <SubGraph.hpp>
#include <SubGraphSelector.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
using namespace armnn;
#include <armnn/Tensor.hpp>
-#include <backends/test/QuantizeHelper.hpp>
+#include <backendsCommon/test/QuantizeHelper.hpp>
#include <cmath>
#include <Logging.hpp>
#include <armnn/Utils.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
-#include <backends/test/LayerTests.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+#include <backendsCommon/test/LayerTests.hpp>
#include "TensorHelpers.hpp"
#include <boost/test/unit_test.hpp>
#include "armnnTfLiteParser/ITfLiteParser.hpp"
-#include <backends/BackendRegistry.hpp>
+#include <backendsCommon/BackendRegistry.hpp>
#include "flatbuffers/idl.h"
#include "flatbuffers/util.h"
#pragma once
#include <armnn/IRuntime.hpp>
-#include <armnn/test/TensorHelpers.hpp>
+#include <test/TensorHelpers.hpp>
#include <armnnOnnxParser/IOnnxParser.hpp>
-#include <armnnUtils/VerificationHelpers.hpp>
+#include <VerificationHelpers.hpp>
-#include <backends/BackendRegistry.hpp>
+#include <backendsCommon/BackendRegistry.hpp>
#include <boost/format.hpp>
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
#include "armnn/Exceptions.hpp"
#include <armnn/Descriptors.hpp>
endif()
add_library(armnnAclCommon OBJECT ${armnnAclCommon_sources})
-target_include_directories(armnnAclCommon PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnAclCommon PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnAclCommon PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnAclCommon PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
//
#pragma once
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#ifdef ARMCOMPUTENEON_ENABLED
#include <arm_compute/runtime/MemoryGroup.h>
)
add_library(armnnAclCommonUnitTests OBJECT ${armnnAclCommonUnitTests_sources})
-target_include_directories(armnnAclCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnAclCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnAclCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnAclCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
//
#pragma once
-#include <armnn/test/CreateWorkload.hpp>
+#include <test/CreateWorkload.hpp>
-#include <backends/MemCopyWorkload.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
+#include <backendsCommon/MemCopyWorkload.hpp>
+#include <reference/RefWorkloadFactory.hpp>
#if ARMCOMPUTECL_ENABLED
-#include <backends/cl/ClTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
#endif
#if ARMCOMPUTENEON_ENABLED
-#include <backends/neon/NeonTensorHandle.hpp>
+#include <neon/NeonTensorHandle.hpp>
#endif
using namespace armnn;
//
#pragma once
-#include <backends/test/LayerTests.hpp>
-#include <backends/test/TensorCopyUtils.hpp>
-#include <backends/test/WorkloadTestUtils.hpp>
+#include <backendsCommon/test/LayerTests.hpp>
+#include <backendsCommon/test/TensorCopyUtils.hpp>
+#include <backendsCommon/test/WorkloadTestUtils.hpp>
-#include <armnn/test/TensorHelpers.hpp>
+#include <test/TensorHelpers.hpp>
#include <boost/multi_array.hpp>
// SPDX-License-Identifier: MIT
//
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/cl/ClWorkloadFactory.hpp>
-#include <backends/neon/NeonWorkloadFactory.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClWorkloadFactory.hpp>
+#include <neon/NeonWorkloadFactory.hpp>
#if ARMCOMPUTECL_ENABLED && ARMCOMPUTENEON_ENABLED
-#include <backends/aclCommon/test/MemCopyTestImpl.hpp>
-#include <backends/cl/test/ClContextControlFixture.hpp>
+#include <aclCommon/test/MemCopyTestImpl.hpp>
+#include <cl/test/ClContextControlFixture.hpp>
#endif
#include <boost/test/unit_test.hpp>
# SPDX-License-Identifier: MIT
#
-add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends)
-list(APPEND armnnLibraries armnnBackendsCommon)
-list(APPEND armnnUnitTestLibraries armnnBackendsCommonUnitTests)
-
# single place to use wildcards, so we can include
# yet unknown backend modules and corresponding common libraries
FILE(GLOB commonIncludes ${PROJECT_SOURCE_DIR}/src/backends/*/common.cmake)
//
#pragma once
-#include <armnn/Types.hpp>
-#include <armnn/IRuntime.hpp>
-#include "RegistryCommon.hpp"
#include "IBackendContext.hpp"
+#include "RegistryCommon.hpp"
+
+#include <armnn/IRuntime.hpp>
+#include <armnn/Types.hpp>
namespace armnn
{
//
#pragma once
-#include <armnn/Types.hpp>
-#include "RegistryCommon.hpp"
#include "IBackendInternal.hpp"
+#include "RegistryCommon.hpp"
+
+#include <armnn/Types.hpp>
namespace armnn
{
endif()
add_library(armnnBackendsCommon OBJECT ${armnnBackendsCommon_sources})
-target_include_directories(armnnBackendsCommon PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnBackendsCommon PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnBackendsCommon PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnBackendsCommon PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
// SPDX-License-Identifier: MIT
//
#include <armnn/Exceptions.hpp>
-#include <backends/CpuTensorHandle.hpp>
+
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <cstring>
#pragma once
#include "CpuTensorHandleFwd.hpp"
+
#include <armnn/TypesUtils.hpp>
-#include <backends/OutputHandler.hpp>
+
+#include <backendsCommon/OutputHandler.hpp>
#include <algorithm>
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
+
#include "MemCopyWorkload.hpp"
+
#include "CpuTensorHandle.hpp"
+
#include <TypeUtils.hpp>
-#include <cstring>
#include <boost/cast.hpp>
+#include <cstring>
+
namespace armnn
{
#include "CpuTensorHandleFwd.hpp"
#include "Workload.hpp"
#include "WorkloadUtils.hpp"
+
#include <utility>
namespace armnn
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
+
#include "OutputHandler.hpp"
+#include "ITensorHandle.hpp"
+#include "WorkloadDataCollector.hpp"
+
+#include <backendsCommon/WorkloadFactory.hpp>
+
#include <boost/assert.hpp>
#include <boost/log/trivial.hpp>
-#include <backends/WorkloadFactory.hpp>
-#include "WorkloadDataCollector.hpp"
-#include "ITensorHandle.hpp"
-
namespace armnn
{
//
#pragma once
-#include <backends/WorkloadDataFwd.hpp>
+#include "ITensorHandle.hpp"
-#include <string>
-#include <vector>
+#include <armnn/Descriptors.hpp>
+#include <armnn/INetwork.hpp>
+#include <armnn/Tensor.hpp>
+#include <armnn/Types.hpp>
+
+#include <backendsCommon/WorkloadDataFwd.hpp>
#include <memory>
#include <set>
+#include <string>
+#include <vector>
#include <boost/assert.hpp>
-#include <armnn/INetwork.hpp>
-#include <armnn/Types.hpp>
-#include <armnn/Descriptors.hpp>
-#include <armnn/Tensor.hpp>
-#include "ITensorHandle.hpp"
-
namespace armnn
{
#include <armnn/BackendId.hpp>
#include <armnn/Exceptions.hpp>
+
#include <functional>
#include <memory>
#include <sstream>
#include "WorkloadData.hpp"
#include "WorkloadInfo.hpp"
+
+#include <Profiling.hpp>
+
#include <algorithm>
-#include "Profiling.hpp"
namespace armnn
{
#include "CpuTensorHandle.hpp"
#include <algorithm>
+#include <iomanip>
#include <string>
#include <sstream>
-#include <iomanip>
#include <boost/format.hpp>
//
#pragma once
+#include "CpuTensorHandleFwd.hpp"
#include "WorkloadDataFwd.hpp"
-#include <armnn/Types.hpp>
-#include <armnn/Tensor.hpp>
+#include <InternalTypes.hpp>
+
#include <armnn/Descriptors.hpp>
#include <armnn/Exceptions.hpp>
-#include <backends/WorkloadInfo.hpp>
-
-#include <InternalTypes.hpp>
-#include <backends/OutputHandler.hpp>
+#include <armnn/Types.hpp>
+#include <armnn/Tensor.hpp>
-#include "CpuTensorHandleFwd.hpp"
+#include <backendsCommon/OutputHandler.hpp>
+#include <backendsCommon/WorkloadInfo.hpp>
namespace armnn
{
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
-#include <backends/WorkloadFactory.hpp>
-#include <backends/LayerSupportRegistry.hpp>
-#include <armnn/Types.hpp>
-#include <armnn/LayerSupport.hpp>
+#include "CpuTensorHandle.hpp"
+
#include <Layer.hpp>
#include <LayersFwd.hpp>
-#include "CpuTensorHandle.hpp"
+
+#include <armnn/Types.hpp>
+#include <armnn/LayerSupport.hpp>
+
+#include <backendsCommon/LayerSupportRegistry.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include <boost/cast.hpp>
-#include <cstring>
#include <boost/iterator/transform_iterator.hpp>
+#include <cstring>
+
namespace armnn
{
//
#pragma once
-#include <memory>
#include <armnn/TensorFwd.hpp>
#include <armnn/Optional.hpp>
-#include <backends/OutputHandler.hpp>
-#include <backends/Workload.hpp>
+
+#include <backendsCommon/OutputHandler.hpp>
+#include <backendsCommon/Workload.hpp>
+
+#include <memory>
namespace armnn
{
#pragma once
-#include "armnn/Tensor.hpp"
#include "ITensorHandle.hpp"
+#include <armnn/Tensor.hpp>
+
#include <boost/cast.hpp>
namespace armnn
--- /dev/null
+#
+# Copyright © 2017 Arm Ltd. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+
+add_subdirectory(${PROJECT_SOURCE_DIR}/src/backends/backendsCommon)
+list(APPEND armnnLibraries armnnBackendsCommon)
+list(APPEND armnnUnitTestLibraries armnnBackendsCommonUnitTests)
#include "TensorCopyUtils.hpp"
#include "WorkloadTestUtils.hpp"
-#include <armnn/test/TensorHelpers.hpp>
+#include <test/TensorHelpers.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <boost/multi_array.hpp>
//
#pragma once
+#include "ActivationFixture.hpp"
+#include "QuantizeHelper.hpp"
+
#include <armnn/ArmNN.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/TypesUtils.hpp>
-#include <test/TensorHelpers.hpp>
-#include "QuantizeHelper.hpp"
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
-#include "ActivationFixture.hpp"
+#include <test/TensorHelpers.hpp>
#include <algorithm>
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
-#include <boost/test/unit_test.hpp>
#include <armnn/BackendId.hpp>
#include <armnn/Types.hpp>
+#include <boost/test/unit_test.hpp>
+
using namespace armnn;
BOOST_AUTO_TEST_SUITE(BackendIdTests)
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
-#include <boost/test/unit_test.hpp>
-#include <backends/BackendRegistry.hpp>
#include <armnn/Types.hpp>
+#include <backendsCommon/BackendRegistry.hpp>
+
+#include <boost/test/unit_test.hpp>
+
namespace
{
#include <armnn/ArmNN.hpp>
#include <armnn/Tensor.hpp>
-#include <test/TensorHelpers.hpp>
-
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+#include <backendsCommon/test/QuantizeHelper.hpp>
-#include <backends/test/QuantizeHelper.hpp>
+#include <test/TensorHelpers.hpp>
template<typename T>
LayerTestResult<T, 4> BatchNormTestImpl(armnn::IWorkloadFactory& workloadFactory,
)
add_library(armnnBackendsCommonUnitTests OBJECT ${armnnBackendsCommonUnitTests_sources})
-target_include_directories(armnnBackendsCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnBackendsCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
-target_include_directories(armnnBackendsCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
\ No newline at end of file
+target_include_directories(armnnBackendsCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnBackendsCommonUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
\ No newline at end of file
#include <test/TensorHelpers.hpp>
#include "QuantizeHelper.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include "Permute.hpp"
#include <boost/numeric/conversion/cast.hpp>
#include <armnn/ArmNN.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/TypesUtils.hpp>
-#include <armnnUtils/Half.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <Half.hpp>
-#include <test/TensorHelpers.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <test/TensorHelpers.hpp>
LayerTestResult<float, 4> SimpleConvertFp16ToFp32Test(armnn::IWorkloadFactory& workloadFactory)
{
#pragma once
+#include <Half.hpp>
+
#include <armnn/ArmNN.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/TypesUtils.hpp>
-#include <armnnUtils/Half.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <test/TensorHelpers.hpp>
#include <armnn/ArmNN.hpp>
-#include <backends/test/QuantizeHelper.hpp>
+#include <backendsCommon/test/QuantizeHelper.hpp>
#include <vector>
//
#pragma once
-#include "Graph.hpp"
+#include <Graph.hpp>
+
+#include <backendsCommon/WorkloadFactory.hpp>
#include <boost/core/ignore_unused.hpp>
// SPDX-License-Identifier: MIT
//
+#include <Profiling.hpp>
+
#include <armnn/Descriptors.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/INetwork.hpp>
-#include <armnn/Profiling.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/algorithm/string.hpp>
// SPDX-License-Identifier: MIT
//
-#include <boost/test/unit_test.hpp>
-#include <boost/cast.hpp>
-
-#include <backends/WorkloadData.hpp>
#include <Graph.hpp>
-#include <utility>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+
+#include <cl/ClWorkloadFactory.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/cl/ClWorkloadFactory.hpp>
+#include <boost/cast.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <utility>
using namespace armnn;
using namespace std;
#include <armnn/LayerSupport.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
#include <algorithm>
#include <boost/cast.hpp>
//
#pragma once
-#include "armnn/ArmNN.hpp"
-#include "armnn/Tensor.hpp"
-#include "armnnUtils/Half.hpp"
+#include <armnn/ArmNN.hpp>
+#include <armnn/Tensor.hpp>
+
+#include <Half.hpp>
#include <boost/multi_array.hpp>
#include <boost/assert.hpp>
+
#include <array>
// Layer callables.
//
#pragma once
+#include "QuantizeHelper.hpp"
+
#include <armnn/ArmNN.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/TypesUtils.hpp>
#include <test/TensorHelpers.hpp>
-#include "QuantizeHelper.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
LayerTestResult<float, 2> LstmNoCifgNoPeepholeNoProjectionTestImpl(armnn::IWorkloadFactory& workloadFactory,
const boost::multi_array<float, 2>& input,
#include <armnn/LayerSupport.hpp>
#include "armnn/Types.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
LayerTestResult<float,4> SimpleNormalizationTestImpl(armnn::IWorkloadFactory& workloadFactory,
armnn::NormalizationAlgorithmChannel normChannel,
//
#include <armnn/ArmNN.hpp>
-#include <armnn/Graph.hpp>
-#include <armnn/Network.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
+#include <Graph.hpp>
+#include <Network.hpp>
+
+#include <reference/RefWorkloadFactory.hpp>
#include <boost/test/unit_test.hpp>
//
#pragma once
+#include "QuantizeHelper.hpp"
+
#include <armnn/ArmNN.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/TypesUtils.hpp>
#include <test/TensorHelpers.hpp>
-#include "QuantizeHelper.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
template<typename T>
LayerTestResult<T, 4> SimplePermuteTestImpl(
//
#pragma once
-#include <string>
+#include "QuantizeHelper.hpp"
+
#include <armnn/ArmNN.hpp>
+#include <Permute.hpp>
+
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+#include <backendsCommon/WorkloadInfo.hpp>
+
#include <test/TensorHelpers.hpp>
-#include "QuantizeHelper.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
-#include <backends/WorkloadInfo.hpp>
-#include <algorithm>
-#include "Permute.hpp"
#include <boost/numeric/conversion/cast.hpp>
+#include <algorithm>
+#include <string>
+
template<typename T>
LayerTestResult<T, 4> SimplePooling2dTestImpl(armnn::IWorkloadFactory& workloadFactory,
armnn::Pooling2dDescriptor descriptor,
//
#pragma once
+#include "QuantizeHelper.hpp"
+
#include <armnn/ArmNN.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/TypesUtils.hpp>
-#include <test/TensorHelpers.hpp>
-#include "QuantizeHelper.hpp"
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <test/TensorHelpers.hpp>
template<typename T>
LayerTestResult<T, 4> SimpleReshapeTestImpl(
#pragma once
#include <armnn/ArmNN.hpp>
-#include <armnn/Runtime.hpp>
+
+#include <Runtime.hpp>
namespace
{
//
#pragma once
+#include "QuantizeHelper.hpp"
+
#include <armnn/ArmNN.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/TypesUtils.hpp>
-#include <test/TensorHelpers.hpp>
-#include "QuantizeHelper.hpp"
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <test/TensorHelpers.hpp>
#include <algorithm>
#include <armnn/ArmNN.hpp>
#include <armnn/Tensor.hpp>
-#include <test/TensorHelpers.hpp>
-
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
-
-#include <backends/test/QuantizeHelper.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+#include <backendsCommon/test/QuantizeHelper.hpp>
+#include <test/TensorHelpers.hpp>
template<typename T>
std::vector<LayerTestResult<T,3>> SplitterTestCommon(armnn::IWorkloadFactory& workloadFactory,
#include "TensorCopyUtils.hpp"
-#include <armnnUtils/Half.hpp>
-
+#include <Half.hpp>
#ifdef ARMCOMPUTECL_ENABLED
-#include <backends/cl/ClTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
#endif
#if ARMCOMPUTENEON_ENABLED
-#include <backends/neon/NeonTensorHandle.hpp>
+#include <neon/NeonTensorHandle.hpp>
#endif
#if ARMCOMPUTECLENABLED || ARMCOMPUTENEON_ENABLED
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#endif
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <boost/cast.hpp>
+
#include <algorithm>
#include <cstring>
#pragma once
#include <armnn/Tensor.hpp>
-#include <backends/ITensorHandle.hpp>
+
+#include <backendsCommon/ITensorHandle.hpp>
void CopyDataToITensorHandle(armnn::ITensorHandle* tensorHandle, const void* mem);
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
-#include <boost/test/unit_test.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/Workload.hpp>
-#include <backends/reference/workloads/RefWorkloads.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
+
+#include "WorkloadTestUtils.hpp"
#include <armnn/Exceptions.hpp>
-#include "WorkloadTestUtils.hpp"
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/Workload.hpp>
+
+#include <reference/workloads/RefWorkloads.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+
+#include <boost/test/unit_test.hpp>
using namespace armnn;
#include <armnn/Tensor.hpp>
+#include <backendsCommon/WorkloadInfo.hpp>
+
namespace armnn
{
class ITensorHandle;
endif()
add_library(armnnClBackend OBJECT ${armnnClBackend_sources})
-target_include_directories(armnnClBackend PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnClBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnClBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnClBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
#include "ClBackendId.hpp"
#include "ClWorkloadFactory.hpp"
-#include <backends/BackendRegistry.hpp>
+#include <backendsCommon/BackendRegistry.hpp>
#include <boost/log/trivial.hpp>
namespace armnn
//
#pragma once
-#include <backends/IBackendInternal.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
namespace armnn
{
#include "ClBackendId.hpp"
#include "ClContextControl.hpp"
-#include <backends/BackendContextRegistry.hpp>
+#include <backendsCommon/BackendContextRegistry.hpp>
#include <boost/log/trivial.hpp>
#include <mutex>
//
#pragma once
-#include <backends/IBackendContext.hpp>
+#include <backendsCommon/IBackendContext.hpp>
namespace armnn
{
#include "ClBackendId.hpp"
#include <armnn/Descriptors.hpp>
-#include <armnn/InternalTypes.hpp>
-#include <armnn/LayerSupportCommon.hpp>
+#include <InternalTypes.hpp>
+#include <LayerSupportCommon.hpp>
-#include <backends/LayerSupportRegistry.hpp>
+#include <backendsCommon/LayerSupportRegistry.hpp>
#include <boost/core/ignore_unused.hpp>
//
#pragma once
-#include <backends/OutputHandler.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <backendsCommon/OutputHandler.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <arm_compute/runtime/CL/CLTensor.h>
#include <arm_compute/runtime/CL/CLSubTensor.h>
#include <armnn/Utils.hpp>
#include <string>
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <Layer.hpp>
#ifdef ARMCOMPUTECL_ENABLED
#include <arm_compute/runtime/CL/CLBufferAllocator.h>
#include <arm_compute/runtime/CL/CLScheduler.h>
-#include <backends/MemCopyWorkload.hpp>
+#include <backendsCommon/MemCopyWorkload.hpp>
-#include <backends/aclCommon/memory/IPoolManager.hpp>
+#include <aclCommon/memory/IPoolManager.hpp>
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/cl/workloads/ClWorkloads.hpp>
-#include <backends/cl/workloads/ClWorkloadUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <cl/workloads/ClWorkloads.hpp>
+#include <cl/workloads/ClWorkloadUtils.hpp>
#endif
-#include <backends/MakeWorkloadHelper.hpp>
+#include <backendsCommon/MakeWorkloadHelper.hpp>
#include <boost/polymorphic_cast.hpp>
#include <boost/format.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/Optional.hpp>
-#include <backends/OutputHandler.hpp>
-#include <backends/aclCommon/memory/BaseMemoryManager.hpp>
+#include <backendsCommon/OutputHandler.hpp>
+#include <aclCommon/memory/BaseMemoryManager.hpp>
namespace armnn
{
#pragma once
-#include <armnn/Instrument.hpp>
+#include <Instrument.hpp>
#include <arm_compute/runtime/CL/CLScheduler.h>
#include <arm_compute/core/CL/OpenCL.h>
)
add_library(armnnClBackendUnitTests OBJECT ${armnnClBackendUnitTests_sources})
-target_include_directories(armnnClBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnClBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnClBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnClBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
#pragma once
-#include <backends/cl/ClContextControl.hpp>
+#include <cl/ClContextControl.hpp>
template<bool ProfilingEnabled>
struct ClContextControlFixtureBase
#include "ClContextControlFixture.hpp"
-#include <backends/MemCopyWorkload.hpp>
+#include <backendsCommon/MemCopyWorkload.hpp>
-#include <backends/aclCommon/test/CreateWorkloadClNeon.hpp>
+#include <aclCommon/test/CreateWorkloadClNeon.hpp>
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/cl/ClWorkloadFactory.hpp>
-#include <backends/cl/workloads/ClWorkloads.hpp>
-#include <backends/cl/workloads/ClWorkloadUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <cl/ClWorkloadFactory.hpp>
+#include <cl/workloads/ClWorkloads.hpp>
+#include <cl/workloads/ClWorkloadUtils.hpp>
boost::test_tools::predicate_result CompareIClTensorHandleShape(IClTensorHandle* tensorHandle,
std::initializer_list<unsigned int> expectedDimensions)
// SPDX-License-Identifier: MIT
//
-#include <backends/test/EndToEndTestImpl.hpp>
+#include <backendsCommon/test/EndToEndTestImpl.hpp>
#include <boost/test/unit_test.hpp>
#include <armnn/BackendId.hpp>
-#include <backends/cl/test/ClContextControlFixture.hpp>
-#include <backends/test/JsonPrinterTestImpl.hpp>
+#include <cl/test/ClContextControlFixture.hpp>
+#include <backendsCommon/test/JsonPrinterTestImpl.hpp>
#include <boost/test/unit_test.hpp>
// SPDX-License-Identifier: MIT
//
-#include <armnn/layers/ConvertFp16ToFp32Layer.hpp>
-#include <armnn/layers/ConvertFp32ToFp16Layer.hpp>
-#include <armnn/test/TensorHelpers.hpp>
-
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/cl/ClWorkloadFactory.hpp>
-#include <backends/cl/test/ClContextControlFixture.hpp>
-#include <backends/test/IsLayerSupportedTestImpl.hpp>
-#include <backends/test/LayerTests.hpp>
+#include <layers/ConvertFp16ToFp32Layer.hpp>
+#include <layers/ConvertFp32ToFp16Layer.hpp>
+#include <test/TensorHelpers.hpp>
+
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <cl/ClWorkloadFactory.hpp>
+#include <cl/test/ClContextControlFixture.hpp>
+#include <backendsCommon/test/IsLayerSupportedTestImpl.hpp>
+#include <backendsCommon/test/LayerTests.hpp>
#include <boost/test/unit_test.hpp>
#include "test/TensorHelpers.hpp"
#include "test/UnitTests.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/cl/ClLayerSupport.hpp>
-#include <backends/cl/ClWorkloadFactory.hpp>
-#include <backends/cl/workloads/ClWorkloadUtils.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
-#include <backends/test/ActivationFixture.hpp>
-#include <backends/test/LayerTests.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <cl/ClLayerSupport.hpp>
+#include <cl/ClWorkloadFactory.hpp>
+#include <cl/workloads/ClWorkloadUtils.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+#include <backendsCommon/test/ActivationFixture.hpp>
+#include <backendsCommon/test/LayerTests.hpp>
#include <arm_compute/core/CL/CLKernelLibrary.h>
#include <arm_compute/runtime/CL/CLScheduler.h>
// SPDX-License-Identifier: MIT
//
-#include <backends/cl/ClWorkloadFactory.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
-#include <backends/aclCommon/test/MemCopyTestImpl.hpp>
+#include <cl/ClWorkloadFactory.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+#include <aclCommon/test/MemCopyTestImpl.hpp>
#include <boost/test/unit_test.hpp>
//
#include <armnn/ArmNN.hpp>
-#include <armnn/Network.hpp>
+#include <Network.hpp>
-#include <armnn/test/GraphUtils.hpp>
+#include <test/GraphUtils.hpp>
-#include <backends/cl/ClWorkloadFactory.hpp>
+#include <cl/ClWorkloadFactory.hpp>
#include <boost/test/unit_test.hpp>
// SPDX-License-Identifier: MIT
//
-#include <armnn/test/RuntimeTests.hpp>
+#include <test/RuntimeTests.hpp>
-#include <armnnUtils/LeakChecking.hpp>
+#include <LeakChecking.hpp>
-#include <backends/test/RuntimeTestImpl.hpp>
+#include <backendsCommon/test/RuntimeTestImpl.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/test/unit_test.hpp>
#include <armnn/Descriptors.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/INetwork.hpp>
-#include <armnnUtils/Half.hpp>
+#include <Half.hpp>
#include <Graph.hpp>
#include <Optimizer.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/test/QuantizeHelper.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/test/QuantizeHelper.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/test/unit_test.hpp>
#if (defined(__aarch64__)) || (defined(__x86_64__)) // disable test failing on FireFly/Armv7
-#include <armnn/test/TensorHelpers.hpp>
+#include <test/TensorHelpers.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
-#include <backends/cl/ClContextControl.hpp>
-#include <backends/cl/ClWorkloadFactory.hpp>
-#include <backends/cl/OpenClTimer.hpp>
+#include <cl/ClContextControl.hpp>
+#include <cl/ClWorkloadFactory.hpp>
+#include <cl/OpenClTimer.hpp>
-#include <backends/test/TensorCopyUtils.hpp>
-#include <backends/test/WorkloadTestUtils.hpp>
+#include <backendsCommon/test/TensorCopyUtils.hpp>
+#include <backendsCommon/test/WorkloadTestUtils.hpp>
#include <arm_compute/runtime/CL/CLScheduler.h>
)
add_library(armnnClBackendWorkloads OBJECT ${armnnClBackendWorkloads_sources})
-target_include_directories(armnnClBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnClBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnClBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnClBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
#include "ClWorkloadUtils.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/cl/ClLayerSupport.hpp>
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <cl/ClLayerSupport.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#include "ClAdditionWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#include "ClBatchNormalizationFloatWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/cl/ClLayerSupport.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClLayerSupport.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#include "ClConstantWorkload.hpp"
-#include <armnnUtils/Half.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <Half.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#include "ClConvertFp16ToFp32Workload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#include "ClConvertFp32ToFp16Workload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#include "ClWorkloadUtils.hpp"
-#include <backends/cl/ClLayerSupport.hpp>
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/cl/ClLayerSupport.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <cl/ClLayerSupport.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <cl/ClLayerSupport.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <arm_compute/runtime/CL/functions/CLConvolutionLayer.h>
#include <armnn/Tensor.hpp>
#include <armnn/Descriptors.hpp>
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/functions/CLConvolutionLayer.h>
#include <arm_compute/runtime/MemoryManagerOnDemand.h>
#include "TypeUtils.hpp"
#include "ClWorkloadUtils.hpp"
-#include <backends/aclCommon/ArmComputeUtils.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <arm_compute/runtime/CL/functions/CLDepthwiseConvolutionLayer.h>
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/IFunction.h>
#include <arm_compute/core/Error.h>
//
#include "ClDivisionFloatWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#include "ClFloorFloatWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#include "ClFullyConnectedWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
-#include <backends/cl/ClLayerSupport.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <cl/ClLayerSupport.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#include <arm_compute/runtime/MemoryManagerOnDemand.h>
//
#include "ClL2NormalizationFloatWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#include "ClLstmFloatWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/cl/ClLayerSupport.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <cl/ClLayerSupport.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <arm_compute/runtime/CL/functions/CLLSTMLayer.h>
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#include "ClMeanWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
namespace armnn
{
//
#include "ClMultiplicationWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include "ClWorkloadUtils.hpp"
namespace armnn
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#include "ClNormalizationFloatWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/cl/ClLayerSupport.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <cl/ClLayerSupport.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include "ClWorkloadUtils.hpp"
using namespace armnn::armcomputetensorutils;
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#include "ClPadWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <arm_compute/core/Types.h>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/WorkloadData.hpp>
-#include <backends/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/functions/CLPadLayer.h>
namespace armnn {
//
#include "ClPermuteWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <arm_compute/core/Error.h>
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
#include <armnn/TypesUtils.hpp>
#include <arm_compute/runtime/CL/functions/CLPermute.h>
//
#include "ClPooling2dWorkload.hpp"
-#include <backends/cl/ClLayerSupport.hpp>
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClLayerSupport.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#include "ClReshapeWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#include "ClResizeBilinearFloatWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/cl/ClLayerSupport.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <cl/ClLayerSupport.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#include "ClSoftmaxBaseWorkload.hpp"
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <arm_compute/runtime/CL/functions/CLSoftmaxLayer.h>
//
#include "ClSoftmaxFloatWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#include <arm_compute/runtime/MemoryManagerOnDemand.h>
//
#include "ClSoftmaxUint8Workload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
#include "arm_compute/runtime/MemoryManagerOnDemand.h"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
namespace armnn
{
#include "ClSubtractionWorkload.hpp"
-#include <backends/cl/ClTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include "ClWorkloadUtils.hpp"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
//
#pragma once
-#include <armnnUtils/Half.hpp>
+#include <Half.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/cl/OpenClTimer.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/OpenClTimer.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <arm_compute/runtime/CL/CLFunctions.h>
endif()
add_library(armnnNeonBackend OBJECT ${armnnNeonBackend_sources})
-target_include_directories(armnnNeonBackend PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnNeonBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnNeonBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnNeonBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
#include "NeonBackendId.hpp"
#include "NeonWorkloadFactory.hpp"
-#include <backends/BackendRegistry.hpp>
+#include <backendsCommon/BackendRegistry.hpp>
namespace armnn
{
//
#pragma once
-#include <backends/IBackendInternal.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
namespace armnn
{
#include "NeonBackendId.hpp"
#include <armnn/Descriptors.hpp>
-#include <armnn/InternalTypes.hpp>
-#include <armnn/LayerSupportCommon.hpp>
+#include <InternalTypes.hpp>
+#include <LayerSupportCommon.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
-#include <backends/LayerSupportRegistry.hpp>
+#include <backendsCommon/LayerSupportRegistry.hpp>
#include <boost/core/ignore_unused.hpp>
//
#pragma once
-#include <backends/OutputHandler.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <backendsCommon/OutputHandler.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <arm_compute/runtime/MemoryGroup.h>
#include <arm_compute/runtime/IMemoryGroup.h>
#include "NeonWorkloadFactory.hpp"
#include "NeonBackendId.hpp"
#include <armnn/Utils.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <Layer.hpp>
#ifdef ARMCOMPUTENEON_ENABLED
#include <arm_compute/runtime/Allocator.h>
-#include <backends/MemCopyWorkload.hpp>
+#include <backendsCommon/MemCopyWorkload.hpp>
#include "NeonTensorHandle.hpp"
#include "workloads/NeonWorkloadUtils.hpp"
#include "workloads/NeonWorkloads.hpp"
-#include <backends/aclCommon/memory/IPoolManager.hpp>
+#include <aclCommon/memory/IPoolManager.hpp>
#endif
-#include <backends/MakeWorkloadHelper.hpp>
+#include <backendsCommon/MakeWorkloadHelper.hpp>
#include <boost/polymorphic_cast.hpp>
#pragma once
#include <armnn/Optional.hpp>
-#include <backends/OutputHandler.hpp>
-#include <backends/aclCommon/memory/BaseMemoryManager.hpp>
+#include <backendsCommon/OutputHandler.hpp>
+#include <aclCommon/memory/BaseMemoryManager.hpp>
#include <boost/core/ignore_unused.hpp>
)
add_library(armnnNeonBackendUnitTests OBJECT ${armnnNeonBackendUnitTests_sources})
-target_include_directories(armnnNeonBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnNeonBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnNeonBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnNeonBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
// SPDX-License-Identifier: MIT
//
-#include <backends/MemCopyWorkload.hpp>
+#include <backendsCommon/MemCopyWorkload.hpp>
-#include <backends/aclCommon/test/CreateWorkloadClNeon.hpp>
+#include <aclCommon/test/CreateWorkloadClNeon.hpp>
-#include <backends/neon/NeonWorkloadFactory.hpp>
-#include <backends/neon/NeonTensorHandle.hpp>
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
-#include <backends/neon/workloads/NeonWorkloads.hpp>
+#include <neon/NeonWorkloadFactory.hpp>
+#include <neon/NeonTensorHandle.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloads.hpp>
BOOST_AUTO_TEST_SUITE(CreateWorkloadNeon)
// SPDX-License-Identifier: MIT
//
-#include <backends/test/EndToEndTestImpl.hpp>
+#include <backendsCommon/test/EndToEndTestImpl.hpp>
#include <boost/test/unit_test.hpp>
#include <armnn/BackendId.hpp>
-#include <backends/test/JsonPrinterTestImpl.hpp>
+#include <backendsCommon/test/JsonPrinterTestImpl.hpp>
#include <boost/test/unit_test.hpp>
// SPDX-License-Identifier: MIT
//
-#include <armnn/layers/ConvertFp16ToFp32Layer.hpp>
-#include <armnn/layers/ConvertFp32ToFp16Layer.hpp>
-#include <armnn/test/TensorHelpers.hpp>
-
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/neon/NeonWorkloadFactory.hpp>
-#include <backends/test/IsLayerSupportedTestImpl.hpp>
-#include <backends/test/LayerTests.hpp>
+#include <layers/ConvertFp16ToFp32Layer.hpp>
+#include <layers/ConvertFp32ToFp16Layer.hpp>
+#include <test/TensorHelpers.hpp>
+
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <neon/NeonWorkloadFactory.hpp>
+#include <backendsCommon/test/IsLayerSupportedTestImpl.hpp>
+#include <backendsCommon/test/LayerTests.hpp>
#include <boost/test/unit_test.hpp>
// SPDX-License-Identifier: MIT
//
-#include <armnn/test/TensorHelpers.hpp>
-#include <armnn/test/UnitTests.hpp>
-
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/neon/NeonLayerSupport.hpp>
-#include <backends/neon/NeonWorkloadFactory.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
-#include <backends/test/ActivationFixture.hpp>
-#include <backends/test/LayerTests.hpp>
-#include <backends/test/TensorCopyUtils.hpp>
-#include <backends/test/WorkloadTestUtils.hpp>
+#include <test/TensorHelpers.hpp>
+#include <test/UnitTests.hpp>
+
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <neon/NeonLayerSupport.hpp>
+#include <neon/NeonWorkloadFactory.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+#include <backendsCommon/test/ActivationFixture.hpp>
+#include <backendsCommon/test/LayerTests.hpp>
+#include <backendsCommon/test/TensorCopyUtils.hpp>
+#include <backendsCommon/test/WorkloadTestUtils.hpp>
#include <boost/test/unit_test.hpp>
// SPDX-License-Identifier: MIT
//
-#include <backends/neon/NeonWorkloadFactory.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
-#include <backends/aclCommon/test/MemCopyTestImpl.hpp>
+#include <neon/NeonWorkloadFactory.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+#include <aclCommon/test/MemCopyTestImpl.hpp>
#include <boost/test/unit_test.hpp>
//
#include <armnn/ArmNN.hpp>
-#include <armnn/Graph.hpp>
-#include <armnn/Network.hpp>
+#include <Graph.hpp>
+#include <Network.hpp>
-#include <backends/neon/NeonWorkloadFactory.hpp>
+#include <neon/NeonWorkloadFactory.hpp>
#include <boost/test/unit_test.hpp>
// SPDX-License-Identifier: MIT
//
-#include <armnn/test/RuntimeTests.hpp>
+#include <test/RuntimeTests.hpp>
-#include <armnnUtils/LeakChecking.hpp>
+#include <LeakChecking.hpp>
-#include <backends/test/RuntimeTestImpl.hpp>
+#include <backendsCommon/test/RuntimeTestImpl.hpp>
#include <boost/test/unit_test.hpp>
#include <armnn/ArmNN.hpp>
-#include <armnn/test/TensorHelpers.hpp>
+#include <test/TensorHelpers.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/WorkloadFactory.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
-#include <backends/neon/NeonTimer.hpp>
-#include <backends/neon/NeonWorkloadFactory.hpp>
+#include <neon/NeonTimer.hpp>
+#include <neon/NeonWorkloadFactory.hpp>
-#include <backends/test/LayerTests.hpp>
-#include <backends/test/TensorCopyUtils.hpp>
-#include <backends/test/WorkloadTestUtils.hpp>
+#include <backendsCommon/test/LayerTests.hpp>
+#include <backendsCommon/test/TensorCopyUtils.hpp>
+#include <backendsCommon/test/WorkloadTestUtils.hpp>
#include <boost/test/unit_test.hpp>
)
add_library(armnnNeonBackendWorkloads OBJECT ${armnnNeonBackendWorkloads_sources})
-target_include_directories(armnnNeonBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnNeonBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnNeonBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnNeonBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
//
#include "NeonActivationWorkload.hpp"
-#include <backends/aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
//
#include "NeonAdditionFloatWorkload.hpp"
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
//
#include "NeonBatchNormalizationFloatWorkload.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <armnn/ArmNN.hpp>
namespace armnn
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
#include "NeonConstantWorkload.hpp"
#include <arm_compute/core/Types.h>
-#include <armnnUtils/Half.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/neon/NeonTensorHandle.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/Workload.hpp>
+#include <Half.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <neon/NeonTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/Workload.hpp>
#include <boost/cast.hpp>
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
#include "NeonConvertFp16ToFp32Workload.hpp"
#include <FloatingPointConverter.hpp>
-#include <armnnUtils/Half.hpp>
-#include <backends/WorkloadUtils.hpp>
+#include <Half.hpp>
+#include <backendsCommon/WorkloadUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
#include "NeonConvertFp32ToFp16Workload.hpp"
-#include <armnnUtils/Half.hpp>
+#include <Half.hpp>
#include <FloatingPointConverter.hpp>
#include <Profiling.hpp>
-#include <backends/WorkloadUtils.hpp>
+#include <backendsCommon/WorkloadUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
#include "NeonConvolution2dWorkload.hpp"
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/neon/NeonLayerSupport.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <neon/NeonLayerSupport.hpp>
#include <armnn/Types.hpp>
-#include <armnnUtils/Half.hpp>
+#include <Half.hpp>
namespace armnn
{
#pragma once
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/neon/NeonLayerSupport.hpp>
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
-#include <backends/Workload.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <neon/NeonLayerSupport.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
+#include <backendsCommon/Workload.hpp>
#include <arm_compute/runtime/MemoryManagerOnDemand.h>
#include "NeonDepthwiseConvolutionWorkload.hpp"
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/neon/NeonLayerSupport.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <neon/NeonLayerSupport.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
#include "NeonFullyConnectedWorkload.hpp"
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
#include <arm_compute/runtime/MemoryManagerOnDemand.h>
//
#include "NeonL2NormalizationFloatWorkload.hpp"
-#include <backends/aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
#include <arm_compute/runtime/MemoryManagerOnDemand.h>
#include <memory>
#include "NeonLstmFloatWorkload.hpp"
#include "NeonWorkloadUtils.hpp"
-#include "backends/CpuTensorHandle.hpp"
-#include "backends/aclCommon/ArmComputeTensorUtils.hpp"
-#include "backends/neon/NeonTensorHandle.hpp"
+#include "backendsCommon/CpuTensorHandle.hpp"
+#include "aclCommon/ArmComputeTensorUtils.hpp"
+#include "neon/NeonTensorHandle.hpp"
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
#include "arm_compute/graph/Tensor.h"
#include "arm_compute/runtime/NEON/functions/NELSTMLayer.h"
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
//
#include "NeonNormalizationFloatWorkload.hpp"
-#include <backends/neon/NeonLayerSupport.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <neon/NeonLayerSupport.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
using namespace armnn::armcomputetensorutils;
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
#include <arm_compute/runtime/MemoryManagerOnDemand.h>
namespace armnn
//
#include "NeonPermuteWorkload.hpp"
-#include <backends/neon/NeonTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <neon/NeonTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <arm_compute/core/Error.h>
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
#include <armnn/TypesUtils.hpp>
#include <arm_compute/runtime/NEON/functions/NEPermute.h>
//
#include "NeonPooling2dWorkload.hpp"
-#include <backends/neon/NeonLayerSupport.hpp>
-#include <backends/neon/NeonTensorHandle.hpp>
-#include <backends/aclCommon/ArmComputeUtils.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <neon/NeonLayerSupport.hpp>
+#include <neon/NeonTensorHandle.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
#include "NeonSoftmaxBaseWorkload.hpp"
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
#include <arm_compute/runtime/MemoryManagerOnDemand.h>
#include <memory>
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
#include <arm_compute/runtime/MemoryManagerOnDemand.h>
namespace armnn
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
namespace armnn
{
//
#include "NeonSubtractionFloatWorkload.hpp"
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
namespace armnn
{
#pragma once
-#include <backends/neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
namespace armnn
{
//
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/aclCommon/ArmComputeTensorUtils.hpp>
-#include <backends/neon/NeonTensorHandle.hpp>
-#include <backends/neon/NeonTimer.hpp>
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <neon/NeonTensorHandle.hpp>
+#include <neon/NeonTimer.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <arm_compute/runtime/NEON/NEFunctions.h>
#include <Half.hpp>
)
add_library(armnnRefBackend OBJECT ${armnnRefBackend_sources})
-target_include_directories(armnnRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnRefBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
add_subdirectory(workloads)
#include "RefBackendId.hpp"
#include "RefWorkloadFactory.hpp"
-#include <backends/BackendRegistry.hpp>
+#include <backendsCommon/BackendRegistry.hpp>
namespace armnn
{
//
#pragma once
-#include <backends/IBackendInternal.hpp>
+#include <backendsCommon/IBackendInternal.hpp>
namespace armnn
{
#include "RefLayerSupport.hpp"
#include "RefBackendId.hpp"
-#include <armnn/InternalTypes.hpp>
-#include <armnn/LayerSupportCommon.hpp>
+#include <InternalTypes.hpp>
+#include <LayerSupportCommon.hpp>
#include <armnn/Types.hpp>
-#include <backends/LayerSupportRegistry.hpp>
+#include <backendsCommon/LayerSupportRegistry.hpp>
#include <boost/core/ignore_unused.hpp>
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/MemCopyWorkload.hpp>
-#include <backends/MakeWorkloadHelper.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/MemCopyWorkload.hpp>
+#include <backendsCommon/MakeWorkloadHelper.hpp>
#include "RefWorkloadFactory.hpp"
#include "RefBackendId.hpp"
#include "workloads/RefWorkloads.hpp"
#pragma once
#include <armnn/Optional.hpp>
-#include <backends/WorkloadFactory.hpp>
-#include <backends/OutputHandler.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+#include <backendsCommon/OutputHandler.hpp>
#include <boost/core/ignore_unused.hpp>
)
add_library(armnnRefBackendUnitTests OBJECT ${armnnRefBackendUnitTests_sources})
-target_include_directories(armnnRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnRefBackendUnitTests PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
// SPDX-License-Identifier: MIT
//
-#include <armnn/test/CreateWorkload.hpp>
+#include <test/CreateWorkload.hpp>
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
-#include <backends/reference/workloads/RefWorkloads.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+#include <reference/workloads/RefWorkloads.hpp>
namespace
{
// SPDX-License-Identifier: MIT
//
-#include <backends/test/EndToEndTestImpl.hpp>
+#include <backendsCommon/test/EndToEndTestImpl.hpp>
#include <boost/test/unit_test.hpp>
#include <armnn/BackendId.hpp>
-#include <backends/test/JsonPrinterTestImpl.hpp>
+#include <backendsCommon/test/JsonPrinterTestImpl.hpp>
#include <boost/test/unit_test.hpp>
// SPDX-License-Identifier: MIT
//
-#include <armnn/layers/ConvertFp16ToFp32Layer.hpp>
-#include <armnn/layers/ConvertFp32ToFp16Layer.hpp>
-#include <armnn/test/TensorHelpers.hpp>
-
-#include <backends/CpuTensorHandle.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
-#include <backends/test/LayerTests.hpp>
-#include <backends/test/IsLayerSupportedTestImpl.hpp>
+#include <layers/ConvertFp16ToFp32Layer.hpp>
+#include <layers/ConvertFp32ToFp16Layer.hpp>
+#include <test/TensorHelpers.hpp>
+
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+#include <backendsCommon/test/LayerTests.hpp>
+#include <backendsCommon/test/IsLayerSupportedTestImpl.hpp>
#include <boost/test/unit_test.hpp>
// SPDX-License-Identifier: MIT
//
-#include "test/TensorHelpers.hpp"
-#include "test/UnitTests.hpp"
+#include <test/TensorHelpers.hpp>
+#include <test/UnitTests.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
-#include <backends/test/LayerTests.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+#include <backendsCommon/test/LayerTests.hpp>
#include <boost/test/unit_test.hpp>
//
#include <armnn/ArmNN.hpp>
-#include <armnn/Graph.hpp>
-#include <armnn/Network.hpp>
+#include <Graph.hpp>
+#include <Network.hpp>
-#include <backends/reference/RefWorkloadFactory.hpp>
+#include <reference/RefWorkloadFactory.hpp>
#include <boost/test/unit_test.hpp>
// SPDX-License-Identifier: MIT
//
-#include <armnn/test/RuntimeTests.hpp>
+#include <test/RuntimeTests.hpp>
-#include <armnnUtils/LeakChecking.hpp>
+#include <LeakChecking.hpp>
-#include <backends/test/RuntimeTestImpl.hpp>
+#include <backendsCommon/test/RuntimeTestImpl.hpp>
#include <boost/test/unit_test.hpp>
)
add_library(armnnRefBackendWorkloads OBJECT ${armnnRefBackendWorkloads_sources})
-target_include_directories(armnnRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src)
target_include_directories(armnnRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
+target_include_directories(armnnRefBackendWorkloads PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
//
#include "Mean.hpp"
-#include "backends/WorkloadData.hpp"
+#include "backendsCommon/WorkloadData.hpp"
#include <boost/numeric/conversion/cast.hpp>
#include "RefWorkloadUtils.hpp"
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/WorkloadData.hpp>
#include <armnn/Tensor.hpp>
namespace armnn
//
#include "Pad.hpp"
-#include "backends/WorkloadData.hpp"
+#include "backendsCommon/WorkloadData.hpp"
#include <boost/numeric/conversion/cast.hpp>
#include "TensorBufferArrayView.hpp"
#include <cmath>
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
#include <armnn/Types.hpp>
-#include <backends/StringMapping.hpp>
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/StringMapping.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
#include <armnn/Types.hpp>
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#include "RefWorkloadUtils.hpp"
#include "FloatingPointConverter.hpp"
-#include <armnnUtils/Half.hpp>
+#include <Half.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#include "RefWorkloadUtils.hpp"
#include "Profiling.hpp"
-#include "armnnUtils/Half.hpp"
+#include "Half.hpp"
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include "backends/Workload.hpp"
-#include "backends/WorkloadData.hpp"
+#include "backendsCommon/Workload.hpp"
+#include "backendsCommon/WorkloadData.hpp"
namespace armnn
{
#pragma once
-#include "backends/Workload.hpp"
-#include "backends/WorkloadData.hpp"
+#include "backendsCommon/Workload.hpp"
+#include "backendsCommon/WorkloadData.hpp"
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
#include <armnn/TypesUtils.hpp>
#pragma once
-#include <backends/Workload.hpp>
+#include <backendsCommon/Workload.hpp>
#include <armnn/TypesUtils.hpp>
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/Workload.hpp>
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
namespace armnn
{
#pragma once
-#include <backends/CpuTensorHandle.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
-#include <armnnUtils/Half.hpp>
+#include <Half.hpp>
#include <boost/polymorphic_cast.hpp>
#include "RefWorkloadUtils.hpp"
-#include <backends/WorkloadData.hpp>
+#include <backendsCommon/WorkloadData.hpp>
#include <armnn/Tensor.hpp>
#include <boost/assert.hpp>
#include <armnnOnnxParser/IOnnxParser.hpp>
#endif
-#include <backends/BackendRegistry.hpp>
+#include <backends/backendsCommon/BackendRegistry.hpp>
#include <boost/exception/exception.hpp>
#include <boost/exception/diagnostic_information.hpp>