From 66aa119b11ba69977b37d25872951a9e17a3565c Mon Sep 17 00:00:00 2001 From: Maksim Doronin Date: Mon, 17 Aug 2020 17:30:38 +0300 Subject: [PATCH] [IE][VPU]: Refactor vpu configs (#1334) * [IE][VPU]: Refactor vpu configs * [IE][VPU][GT]: Refactor vpu configs usage in GT * [IE][VPU]: Refactor vpu configs usage in myriad plugin * [IE][VPU]: Refactor vpu configs usage in tests * [IE][VPU]: Refactor vpu configs usage in deprecated_tests * [IE][VPU]: Refactor vpu configs usage in tools * [IE][VPU]: Use hddl metric vars instead of macros * [IE][VPU]: style fixes * [IE][VPU]: Replace MYRIAD_FORCE_RESET with MYRIAD_ENABLE_FORCE_RESET * [IE][VPU]: Resolve confilcts with MYRIAD_TILING_CMX_LIMIT_KB * [IE][VPU]: Remove MYRIAD_PLATFORM from tools * [IE][VPU]: Fix DISABLE_REORDER config in StridedSlice * [IE][VPU]: Redesign config headers hierarchy * [IE][VPU]: Clarify comments related to vpu configs * [IE][VPU]: Leave default values of deprecated configs * [IE][VPU]: Revert beh tests on VPU_MYRIAD_PLATFORM * [IE][VPU]: Revert beh tests with deprecated configs * [IE][VPU]: Resolve conflicts * [IE][VPU]: Revert opencv dependency --- inference-engine/include/vpu/hddl_config.hpp | 177 ++++++++++++++++++ .../include/vpu/hddl_plugin_config.hpp | 44 ++++- .../include/vpu/myriad_config.hpp | 62 ++++++ .../include/vpu/myriad_plugin_config.hpp | 19 +- inference-engine/include/vpu/vpu_config.hpp | 50 +++++ .../include/vpu/vpu_plugin_config.hpp | 54 ++---- .../include/vpu/parsed_config.hpp | 2 +- .../include/vpu/private_plugin_config.hpp | 90 ++++----- .../src/graph_transformer.cpp | 10 +- .../graph_transformer/src/parsed_config.cpp | 168 +++++++++-------- .../src/vpu/myriad_plugin/myriad_config.cpp | 106 ++++++----- .../src/vpu/myriad_plugin/myriad_metrics.cpp | 26 ++- .../src/vpu/myriad_plugin/myriad_plugin.cpp | 21 ++- .../behavior/config.cpp | 72 +++++-- .../behavior/infer_request_config.cpp | 35 +++- .../single_layer_tests/eltwise.cpp | 4 +- .../single_layer_tests/nonzero.cpp | 4 +- .../single_layer_tests/strided_slice.cpp | 2 +- .../out_shape_of_reshape.cpp | 4 +- .../static_shape_broadcast.cpp | 2 +- .../static_shape_nonzero.cpp | 4 +- .../subgraph_tests/dsr_tests_common.hpp | 4 +- .../subgraph_tests/nonzero_broadcast.cpp | 4 +- .../helpers/myriad_protocol_case.cpp | 6 +- .../vpu/myriad_tests/vpu_boot_tests.cpp | 4 +- .../vpu/myriad_tests/vpu_watchdog_tests.cpp | 2 +- .../plugin_tests/vpu_test_data.hpp | 88 +++++++-- .../layers/myriad_layers_CTCDecoder_test.hpp | 2 +- .../common/layers/myriad_layers_bias_test.hpp | 2 +- .../common/layers/myriad_layers_blob_test.cpp | 27 ++- .../layers/myriad_layers_clamp_test.hpp | 2 +- .../layers/myriad_layers_conv_nd_test.hpp | 4 +- .../layers/myriad_layers_convert_test.hpp | 4 +- .../layers/myriad_layers_convolution1x1.hpp | 8 +- .../layers/myriad_layers_convolution3x3.hpp | 10 +- .../layers/myriad_layers_convolution_test.hpp | 12 +- .../common/layers/myriad_layers_copy_test.hpp | 2 +- .../layers/myriad_layers_custom_test.hpp | 16 +- .../myriad_layers_deconvolution_test.hpp | 8 +- .../layers/myriad_layers_eltwise_test.cpp | 28 +-- .../layers/myriad_layers_eltwise_test.hpp | 4 +- .../common/layers/myriad_layers_elu_test.hpp | 2 +- .../common/layers/myriad_layers_erf_test.hpp | 2 +- ...myriad_layers_exp_detectionoutput_test.hpp | 2 +- ...riad_layers_exp_generateproposals_test.hpp | 2 +- ...iad_layers_exp_priorgridgenerator_test.hpp | 2 +- .../myriad_layers_exp_topkrois_test.hpp | 2 +- .../myriad_layers_fully_connected_tests.hpp | 8 +- .../layers/myriad_layers_gather_test.hpp | 2 +- .../common/layers/myriad_layers_gemm_test.hpp | 4 +- .../common/layers/myriad_layers_grn_test.hpp | 4 +- .../common/layers/myriad_layers_mvn_test.cpp | 2 +- .../common/layers/myriad_layers_mvn_test.hpp | 2 +- .../layers/myriad_layers_nonzero_test.hpp | 2 +- .../layers/myriad_layers_oneHot_test.hpp | 2 +- .../layers/myriad_layers_permute_nd_test.hpp | 4 +- .../layers/myriad_layers_permute_test.hpp | 4 +- .../layers/myriad_layers_pool_nd_test.hpp | 2 +- .../layers/myriad_layers_pooling_test.hpp | 8 +- .../layers/myriad_layers_power_test.hpp | 2 +- .../layers/myriad_layers_prelu_test.hpp | 2 +- .../layers/myriad_layers_reduce_test.hpp | 2 +- .../layers/myriad_layers_region_test.hpp | 4 +- .../common/layers/myriad_layers_relu_test.hpp | 7 +- .../layers/myriad_layers_reorg_test.hpp | 4 +- .../layers/myriad_layers_resample_test.hpp | 2 +- .../layers/myriad_layers_reshape_test.cpp | 13 +- .../layers/myriad_layers_reshape_test.hpp | 8 +- .../myriad_layers_reverse_sequence_test.hpp | 2 +- .../layers/myriad_layers_roi_align_test.hpp | 4 +- ...riad_layers_roi_feature_extractor_test.hpp | 2 +- .../layers/myriad_layers_scale_test.hpp | 2 +- ...ad_layers_scatter_elements_update_test.hpp | 2 +- .../myriad_layers_scatter_update_test.hpp | 2 +- .../layers/myriad_layers_select_test.hpp | 2 +- .../layers/myriad_layers_sigmoid_test.hpp | 2 +- .../layers/myriad_layers_slice_test.hpp | 2 +- .../layers/myriad_layers_softmax_test.hpp | 2 +- .../layers/myriad_layers_split_test.hpp | 2 +- .../layers/myriad_layers_strided_slice_test.h | 4 +- .../common/layers/myriad_layers_tanh_test.hpp | 2 +- .../common/layers/myriad_layers_tile_test.hpp | 2 +- .../common/layers/myriad_layers_topk_test.hpp | 2 +- .../vpu/common/myriad_hw_conv_tests.hpp | 2 +- .../vpu/common/myriad_hw_extra_tests.hpp | 6 +- .../vpu/common/myriad_hw_fc_tests.hpp | 2 +- .../vpu/common/myriad_hw_network_tests.hpp | 4 +- .../vpu/common/myriad_hw_pool_tests.hpp | 2 +- .../vpu/common/myriad_hw_tests_base.hpp | 4 +- .../vpu/common/myriad_merge_permute_tests.hpp | 4 +- .../vpu/myriad_tests/myriad_configs_tests.cpp | 28 +-- .../myriad_streams_configuration_tests.cpp | 2 +- .../vpu/vpu_base/myriad_layers_tests.cpp | 4 +- .../vpu/vpu_base/myriad_layers_tests.hpp | 2 +- .../vpu/vpu_base/vpu_layers_tests.cpp | 10 +- .../helpers/tests_vpu_common.hpp | 17 +- .../vpu/myriad_tests/myriad_engine_tests.cpp | 67 ++++--- .../vpu/myriad_tests/myriad_metrics_tests.cpp | 4 +- inference-engine/tools/compile_tool/README.md | 9 - inference-engine/tools/compile_tool/main.cpp | 22 +-- .../tools/vpu/vpu_compile/README.md | 8 - .../tools/vpu/vpu_compile/main.cpp | 17 +- .../tools/vpu/vpu_perfcheck/main.cpp | 6 +- 103 files changed, 991 insertions(+), 556 deletions(-) create mode 100644 inference-engine/include/vpu/hddl_config.hpp create mode 100644 inference-engine/include/vpu/myriad_config.hpp create mode 100644 inference-engine/include/vpu/vpu_config.hpp diff --git a/inference-engine/include/vpu/hddl_config.hpp b/inference-engine/include/vpu/hddl_config.hpp new file mode 100644 index 00000000000..5b669fa35bc --- /dev/null +++ b/inference-engine/include/vpu/hddl_config.hpp @@ -0,0 +1,177 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * @brief A header that defines advanced related properties for HDDL plugin. + * These properties should be used in SetConfig() and LoadNetwork() methods of plugins + * + * @file hddl_config.hpp + */ + +#pragma once + +#include "vpu_config.hpp" + +namespace InferenceEngine { + +namespace Metrics { + +/** +* @brief Metric to get a int of the device number, String value is METRIC_HDDL_DEVICE_NUM +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_NUM, int); + +/** +* @brief Metric to get a std::vector of device names, String value is METRIC_HDDL_DEVICE_NAME +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_NAME, std::vector); + +/** +* @brief Metric to get a std::vector of device thermal, String value is METRIC_HDDL_DEVICE_THERMAL +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_THERMAL, std::vector); + +/** +* @brief Metric to get a std::vector of device ids, String value is METRIC_HDDL_DEVICE_ID +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_ID, std::vector); + +/** +* @brief Metric to get a std::vector of device subclasses, String value is METRIC_HDDL_DEVICE_SUBCLASS +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_SUBCLASS, std::vector); + +/** +* @brief Metric to get a std::vector of device total memory, String value is METRIC_HDDL_MEMORY_TOTAL +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_MEMORY_TOTAL, std::vector); + +/** +* @brief Metric to get a std::vector of device used memory, String value is METRIC_HDDL_DEVICE_MEMORY_USED +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_MEMORY_USED, std::vector); + +/** +* @brief Metric to get a std::vector of device utilization, String value is METRIC_HDDL_DEVICE_UTILIZATION +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_UTILIZATION, std::vector); + +/** +* @brief Metric to get a std::vector of stream ids, String value is METRIC_HDDL_DEVICE_STREAM_ID +*/ +DECLARE_METRIC_KEY(HDDL_STREAM_ID, std::vector); + +/** +* @brief Metric to get a std::vector of device tags, String value is METRIC_HDDL_DEVICE_TAG +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_TAG, std::vector); + +/** +* @brief Metric to get a std::vector of group ids, String value is METRIC_HDDL_GROUP_ID +*/ +DECLARE_METRIC_KEY(HDDL_GROUP_ID, std::vector); + +/** +* @brief Metric to get a int number of device be using for group, String value is METRIC_HDDL_DEVICE_GROUP_USING_NUM +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_GROUP_USING_NUM, int); + +/** +* @brief Metric to get a int number of total device, String value is METRIC_HDDL_DEVICE_TOTAL_NUM +*/ +DECLARE_METRIC_KEY(HDDL_DEVICE_TOTAL_NUM, int); + +} // namespace Metrics + +/** + * @brief [Only for HDDLPlugin] + * Type: Arbitrary non-empty string. If empty (""), equals no set, default: ""; + * This option allows to specify the number of MYX devices used for inference a specific Executable network. + * Note: Only one network would be allocated to one device. + * The number of devices for the tag is specified in the hddl_service.config file. + * Example: + * "service_settings": + * { + * "graph_tag_map": + * { + * "tagA":3 + * } + * } + * It means that an executable network marked with tagA will be executed on 3 devices + */ +DECLARE_VPU_CONFIG(HDDL_GRAPH_TAG); + +/** + * @brief [Only for HDDLPlugin] + * Type: Arbitrary non-empty string. If empty (""), equals no set, default: ""; + * This config makes the executable networks to be allocated on one certain device (instead of multiple devices). + * And all inference through this executable network, will be done on this device. + * Note: Only one network would be allocated to one device. + * The number of devices which will be used for stream-affinity must be specified in hddl_service.config file. + * Example: + * "service_settings": + * { + * "stream_device_number":5 + * } + * It means that 5 device will be used for stream-affinity + */ +DECLARE_VPU_CONFIG(HDDL_STREAM_ID); + +/** + * @brief [Only for HDDLPlugin] + * Type: Arbitrary non-empty string. If empty (""), equals no set, default: ""; + * This config allows user to control device flexibly. This config gives a "tag" for a certain device while + * allocating a network to it. Afterward, user can allocating/deallocating networks to this device with this "tag". + * Devices used for such use case is controlled by a so-called "Bypass Scheduler" in HDDL backend, and the number + * of such device need to be specified in hddl_service.config file. + * Example: + * "service_settings": + * { + * "bypass_device_number": 5 + * } + * It means that 5 device will be used for Bypass scheduler. + */ +DECLARE_VPU_CONFIG(HDDL_DEVICE_TAG); + +/** + * @brief [Only for HDDLPlugin] + * Type: "YES/NO", default is "NO". + * This config is a sub-config of DEVICE_TAG, and only available when "DEVICE_TAG" is set. After a user load a + * network, the user got a handle for the network. + * If "YES", the network allocated is bind to the device (with the specified "DEVICE_TAG"), which means all afterwards + * inference through this network handle will be executed on this device only. + * If "NO", the network allocated is not bind to the device (with the specified "DEVICE_TAG"). If the same network + * is allocated on multiple other devices (also set BIND_DEVICE to "False"), then inference through any handle of these + * networks may be executed on any of these devices those have the network loaded. + */ +DECLARE_VPU_CONFIG(HDDL_BIND_DEVICE); + +/** + * @brief [Only for HDDLPlugin] + * Type: A signed int wrapped in a string, default is "0". + * This config is a sub-config of DEVICE_TAG, and only available when "DEVICE_TAG" is set and "BIND_DEVICE" is "False". + * When there are multiple devices running a certain network (a same network running on multiple devices in Bypass Scheduler), + * the device with a larger number has a higher priority, and more inference tasks will be fed to it with priority. + */ +DECLARE_VPU_CONFIG(HDDL_RUNTIME_PRIORITY); + +/** + * @brief [Only for HDDLPlugin] + * Type: "YES/NO", default is "NO". + * SGAD is short for "Single Graph All Device". With this scheduler, once application allocates 1 network, all devices + * (managed by SGAD scheduler) will be loaded with this graph. The number of network that can be loaded to one device + * can exceed one. Once application deallocates 1 network from device, all devices will unload the network from them. + */ +DECLARE_VPU_CONFIG(HDDL_USE_SGAD); + +/** + * @brief [Only for HDDLPlugin] + * Type: A signed int wrapped in a string, default is "0". + * This config gives a "group id" for a certain device when this device has been reserved for certain client, client + * can use this device grouped by calling this group id while other client can't use this device + * Each device has their own group id. Device in one group shares same group id. + */ +DECLARE_VPU_CONFIG(HDDL_GROUP_DEVICE); + +} // namespace InferenceEngine diff --git a/inference-engine/include/vpu/hddl_plugin_config.hpp b/inference-engine/include/vpu/hddl_plugin_config.hpp index c7e1db5b23e..78388ca5f87 100644 --- a/inference-engine/include/vpu/hddl_plugin_config.hpp +++ b/inference-engine/include/vpu/hddl_plugin_config.hpp @@ -3,6 +3,7 @@ // /** + * @deprecated Use vpu/hddl_config.hpp instead. * @brief A header that defines advanced related properties for VPU plugins. * These properties should be used in SetConfig() and LoadNetwork() methods of plugins * @@ -11,6 +12,7 @@ #pragma once +#include "ie_api.h" #include "ie_plugin_config.hpp" // @@ -47,68 +49,94 @@ namespace InferenceEngine { namespace Metrics { /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_NUM instead * @brief Metric to get a int of the device number, String value is METRIC_VPU_HDDL_DEVICE_NUM */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_NUM instead") DECLARE_VPU_HDDL_METRIC(DEVICE_NUM, int); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_NAME instead * @brief Metric to get a std::vector of device names, String value is METRIC_VPU_HDDL_DEVICE_NAME */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_NAME instead") DECLARE_VPU_HDDL_METRIC(DEVICE_NAME, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_THERMAL instead * @brief Metric to get a std::vector of device thermal, String value is METRIC_VPU_HDDL_DEVICE_THERMAL */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_THERMAL instead") DECLARE_VPU_HDDL_METRIC(DEVICE_THERMAL, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_ID instead * @brief Metric to get a std::vector of device ids, String value is METRIC_VPU_HDDL_DEVICE_ID */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_ID instead") DECLARE_VPU_HDDL_METRIC(DEVICE_ID, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_SUBCLASS instead * @brief Metric to get a std::vector of device subclasses, String value is METRIC_VPU_HDDL_DEVICE_SUBCLASS */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_SUBCLASS instead") DECLARE_VPU_HDDL_METRIC(DEVICE_SUBCLASS, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_MEMORY_TOTAL instead * @brief Metric to get a std::vector of device total memory, String value is METRIC_VPU_HDDL_MEMORY_TOTAL */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_MEMORY_TOTAL instead") DECLARE_VPU_HDDL_METRIC(DEVICE_MEMORY_TOTAL, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_MEMORY_USED instead * @brief Metric to get a std::vector of device used memory, String value is METRIC_VPU_HDDL_DEVICE_MEMORY_USED */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_MEMORY_USED instead") DECLARE_VPU_HDDL_METRIC(DEVICE_MEMORY_USED, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_UTILIZATION instead * @brief Metric to get a std::vector of device utilization, String value is METRIC_VPU_HDDL_DEVICE_UTILIZATION */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_UTILIZATION instead") DECLARE_VPU_HDDL_METRIC(DEVICE_UTILIZATION, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_STREAM_ID instead * @brief Metric to get a std::vector of stream ids, String value is METRIC_VPU_HDDL_DEVICE_STREAM_ID */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_STREAM_ID instead") DECLARE_VPU_HDDL_METRIC(STREAM_ID, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_TAG instead * @brief Metric to get a std::vector of device tags, String value is METRIC_VPU_HDDL_DEVICE_TAG */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_TAG instead") DECLARE_VPU_HDDL_METRIC(DEVICE_TAG, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_GROUP_ID instead * @brief Metric to get a std::vector of group ids, String value is METRIC_VPU_HDDL_GROUP_ID */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_GROUP_ID instead") DECLARE_VPU_HDDL_METRIC(GROUP_ID, std::vector); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_GROUP_USING_NUM instead * @brief Metric to get a int number of device be using for group, String value is METRIC_VPU_HDDL_DEVICE_GROUP_USING_NUM */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_GROUP_USING_NUM instead") DECLARE_VPU_HDDL_METRIC(DEVICE_GROUP_USING_NUM, int); /** +* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_TOTAL_NUM instead * @brief Metric to get a int number of total device, String value is METRIC_VPU_HDDL_DEVICE_TOTAL_NUM */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::METRIC_HDDL_DEVICE_TOTAL_NUM instead") DECLARE_VPU_HDDL_METRIC(DEVICE_TOTAL_NUM, int); } // namespace Metrics @@ -116,6 +144,7 @@ DECLARE_VPU_HDDL_METRIC(DEVICE_TOTAL_NUM, int); namespace VPUConfigParams { /** + * @deprecated Use InferenceEngine::HDDL_GRAPH_TAG instead * @brief [Only for HDDLPlugin] * Type: Arbitrary non-empty string. If empty (""), equals no set, default: ""; * This option allows to specify the number of MYX devices used for inference a specific Executable network. @@ -131,9 +160,11 @@ namespace VPUConfigParams { * } * It means that an executable network marked with tagA will be executed on 3 devices */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::HDDL_GRAPH_TAG instead") DECLARE_VPU_HDDL_CONFIG_KEY(GRAPH_TAG); /** + * @deprecated Use InferenceEngine::HDDL_STREAM_ID instead * @brief [Only for HDDLPlugin] * Type: Arbitrary non-empty string. If empty (""), equals no set, default: ""; * This config makes the executable networks to be allocated on one certain device (instead of multiple devices). @@ -147,9 +178,11 @@ DECLARE_VPU_HDDL_CONFIG_KEY(GRAPH_TAG); * } * It means that 5 device will be used for stream-affinity */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::HDDL_STREAM_ID instead") DECLARE_VPU_HDDL_CONFIG_KEY(STREAM_ID); /** + * @deprecated Use InferenceEngine::HDDL_DEVICE_TAG instead * @brief [Only for HDDLPlugin] * Type: Arbitrary non-empty string. If empty (""), equals no set, default: ""; * This config allows user to control device flexibly. This config gives a "tag" for a certain device while @@ -163,9 +196,11 @@ DECLARE_VPU_HDDL_CONFIG_KEY(STREAM_ID); * } * It means that 5 device will be used for Bypass scheduler. */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::HDDL_DEVICE_TAG instead") DECLARE_VPU_HDDL_CONFIG_KEY(DEVICE_TAG); /** + * @deprecated Use InferenceEngine::HDDL_BIND_DEVICE instead * @brief [Only for HDDLPlugin] * Type: "YES/NO", default is "NO". * This config is a sub-config of DEVICE_TAG, and only available when "DEVICE_TAG" is set. After a user load a @@ -176,33 +211,40 @@ DECLARE_VPU_HDDL_CONFIG_KEY(DEVICE_TAG); * is allocated on multiple other devices (also set BIND_DEVICE to "False"), then inference through any handle of these * networks may be executed on any of these devices those have the network loaded. */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::HDDL_BIND_DEVICE instead") DECLARE_VPU_HDDL_CONFIG_KEY(BIND_DEVICE); /** + * @deprecated Use InferenceEngine::HDDL_RUNTIME_PRIORITY instead * @brief [Only for HDDLPlugin] * Type: A signed int wrapped in a string, default is "0". * This config is a sub-config of DEVICE_TAG, and only available when "DEVICE_TAG" is set and "BIND_DEVICE" is "False". * When there are multiple devices running a certain network (a same network running on multiple devices in Bypass Scheduler), * the device with a larger number has a higher priority, and more inference tasks will be fed to it with priority. */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::HDDL_RUNTIME_PRIORITY instead") DECLARE_VPU_HDDL_CONFIG_KEY(RUNTIME_PRIORITY); /** + * @deprecated Use InferenceEngine::HDDL_USE_SGAD instead * @brief [Only for HDDLPlugin] * Type: "YES/NO", default is "NO". * SGAD is short for "Single Graph All Device". With this scheduler, once application allocates 1 network, all devices * (managed by SGAD scheduler) will be loaded with this graph. The number of network that can be loaded to one device * can exceed one. Once application deallocates 1 network from device, all devices will unload the network from them. */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::HDDL_USE_SGAD instead") DECLARE_VPU_HDDL_CONFIG_KEY(USE_SGAD); /** + * @deprecated Use InferenceEngine::HDDL_GROUP_DEVICE instead * @brief [Only for HDDLPlugin] * Type: A signed int wrapped in a string, default is "0". * This config gives a "group id" for a certain device when this device has been reserved for certain client, client * can use this device grouped by calling this group id while other client can't use this device * Each device has their own group id. Device in one group shares same group id. - */ + */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::HDDL_GROUP_DEVICE instead") DECLARE_VPU_HDDL_CONFIG_KEY(GROUP_DEVICE); } // namespace VPUConfigParams diff --git a/inference-engine/include/vpu/myriad_config.hpp b/inference-engine/include/vpu/myriad_config.hpp new file mode 100644 index 00000000000..76393bca6a6 --- /dev/null +++ b/inference-engine/include/vpu/myriad_config.hpp @@ -0,0 +1,62 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * @brief A header that defines advanced related properties for Myriad plugin. + * These properties should be used in SetConfig() and LoadNetwork() methods of plugins + * + * @file myriad_config.hpp + */ + +#pragma once + +#include "vpu_config.hpp" + +namespace InferenceEngine { + +/** + * @brief The flag to reset stalled devices. + * This is a plugin scope option and must be used with the plugin's SetConfig method + * The only possible values are: + * CONFIG_VALUE(YES) + * CONFIG_VALUE(NO) (default value) + */ +DECLARE_VPU_CONFIG(MYRIAD_ENABLE_FORCE_RESET); + +/** + * @brief This option allows to specify device memory type. + */ +DECLARE_VPU_CONFIG(MYRIAD_DDR_TYPE); + +/** + * @brief Supported keys definition for InferenceEngine::MYRIAD_DDR_TYPE option. + */ +DECLARE_VPU_CONFIG(MYRIAD_DDR_AUTO); +DECLARE_VPU_CONFIG(MYRIAD_DDR_MICRON_2GB); +DECLARE_VPU_CONFIG(MYRIAD_DDR_SAMSUNG_2GB); +DECLARE_VPU_CONFIG(MYRIAD_DDR_HYNIX_2GB); +DECLARE_VPU_CONFIG(MYRIAD_DDR_MICRON_1GB); + +/** + * @brief This option allows to specify protocol. + */ +DECLARE_VPU_CONFIG(MYRIAD_PROTOCOL); + +/** + * @brief Supported keys definition for InferenceEngine::MYRIAD_PROTOCOL option. + */ +DECLARE_VPU_CONFIG(MYRIAD_PCIE); +DECLARE_VPU_CONFIG(MYRIAD_USB); + +/** + * @brief Optimize vpu plugin execution to maximize throughput. + * This option should be used with integer value which is the requested number of streams. + * The only possible values are: + * 1 + * 2 + * 3 + */ +DECLARE_VPU_CONFIG(MYRIAD_THROUGHPUT_STREAMS); + +} // namespace InferenceEngine diff --git a/inference-engine/include/vpu/myriad_plugin_config.hpp b/inference-engine/include/vpu/myriad_plugin_config.hpp index 75cd3e222d8..e3d223b45ff 100644 --- a/inference-engine/include/vpu/myriad_plugin_config.hpp +++ b/inference-engine/include/vpu/myriad_plugin_config.hpp @@ -3,14 +3,16 @@ // /** + * @deprecated Use vpu/myriad_config.hpp instead. * @brief A header that defines advanced related properties for VPU plugins. * These properties should be used in SetConfig() and LoadNetwork() methods of plugins * - * @file myriad_plugin_config + * @file myriad_plugin_config.hpp */ #pragma once +#include "ie_api.h" #include "ie_plugin_config.hpp" /** @@ -32,35 +34,50 @@ namespace InferenceEngine { namespace VPUConfigParams { /** + * @deprecated Use InferenceEngine::MYRIAD_ENABLE_FORCE_RESET instead. * @brief The flag to reset stalled devices: CONFIG_VALUE(YES) or CONFIG_VALUE(NO) (default) * This is a plugin scope option and must be used with the plugin's SetConfig method */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_ENABLE_FORCE_RESET instead") DECLARE_VPU_MYRIAD_CONFIG_KEY(FORCE_RESET); /** + * @deprecated * @brief This option allows to specify device. * If specified device is not available then creating infer request will throw an exception. */ +INFERENCE_ENGINE_DEPRECATED("") DECLARE_VPU_MYRIAD_CONFIG_KEY(PLATFORM); /** + * @deprecated * @brief Supported keys definition for VPU_MYRIAD_CONFIG_KEY(PLATFORM) option. */ +INFERENCE_ENGINE_DEPRECATED("") DECLARE_VPU_MYRIAD_CONFIG_VALUE(2450); +INFERENCE_ENGINE_DEPRECATED("") DECLARE_VPU_MYRIAD_CONFIG_VALUE(2480); /** + * @deprecated Use InferenceEngine::MYRIAD_DDR_TYPE instead * @brief This option allows to specify device memory type. */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_DDR_TYPE instead") DECLARE_VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE); /** + * @deprecated Use DDR type values from InferenceEngine namespace with MYRIAD_DDR_ prefix * @brief Supported keys definition for VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE) option. */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_DDR_AUTO instead") DECLARE_VPU_MYRIAD_CONFIG_VALUE(DDR_AUTO); +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_DDR_MICRON_2GB instead") DECLARE_VPU_MYRIAD_CONFIG_VALUE(MICRON_2GB); +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_DDR_SAMSUNG_2GB instead") DECLARE_VPU_MYRIAD_CONFIG_VALUE(SAMSUNG_2GB); +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_DDR_HYNIX_2GB instead") DECLARE_VPU_MYRIAD_CONFIG_VALUE(HYNIX_2GB); +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_DDR_MICRON_1GB instead") DECLARE_VPU_MYRIAD_CONFIG_VALUE(MICRON_1GB); } // namespace VPUConfigParams diff --git a/inference-engine/include/vpu/vpu_config.hpp b/inference-engine/include/vpu/vpu_config.hpp new file mode 100644 index 00000000000..df46da327d8 --- /dev/null +++ b/inference-engine/include/vpu/vpu_config.hpp @@ -0,0 +1,50 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * @brief A header that defines common config subset for VPU plugins. + * Include myriad_config.hpp or hddl_config.hpp directly. + * These properties should be used in SetConfig() and LoadNetwork() methods of plugins + * + * @file vpu_config.hpp + */ + +#pragma once + +#include "ie_plugin_config.hpp" +#include "ie_api.h" + +#include + +#define DECLARE_VPU_CONFIG(name) static constexpr auto name = #name + +namespace InferenceEngine { + +// +// Common options +// + +/** + * @brief Turn on HW stages usage (applicable for MyriadX devices only). + * The only possible values are: + * CONFIG_VALUE(YES) (default value) + * CONFIG_VALUE(NO) + */ +DECLARE_VPU_CONFIG(MYRIAD_ENABLE_HW_ACCELERATION); + +/** + * @brief The flag for adding to the profiling information the time of obtaining a tensor. + * The only possible values are: + * CONFIG_VALUE(YES) + * CONFIG_VALUE(NO) (default value) + */ +DECLARE_VPU_CONFIG(MYRIAD_ENABLE_RECEIVING_TENSOR_TIME); + +/** + * @brief This option allows to pass custom layers binding xml. + * If layer is present in such an xml, it would be used during inference even if the layer is natively supported + */ +DECLARE_VPU_CONFIG(MYRIAD_CUSTOM_LAYERS); + +} // namespace InferenceEngine diff --git a/inference-engine/include/vpu/vpu_plugin_config.hpp b/inference-engine/include/vpu/vpu_plugin_config.hpp index e05eae4f4c2..bf547e8d9b1 100644 --- a/inference-engine/include/vpu/vpu_plugin_config.hpp +++ b/inference-engine/include/vpu/vpu_plugin_config.hpp @@ -3,6 +3,7 @@ // /** + * @deprecated Use vpu/myriad_config.hpp or vpu/hddl_config.hpp instead. * @brief A header that defines advanced related properties for VPU plugins. * These properties should be used in SetConfig() and LoadNetwork() methods of plugins * @@ -44,9 +45,11 @@ namespace VPUConfigParams { // /** + * @deprecated Use InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION instead. * @brief Turn on HW stages usage (applicable for MyriadX devices only). * This option should be used with values: CONFIG_VALUE(YES) or CONFIG_VALUE(NO) (default) */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION instead") DECLARE_VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION); /** @@ -57,33 +60,13 @@ INFERENCE_ENGINE_DEPRECATED("Use CONFIG_KEY(LOG_LEVEL) instead") DECLARE_VPU_CONFIG_KEY(LOG_LEVEL); /** - * @deprecated - * @brief The key to define normalization coefficient for the network input. - * This option should used with be a real number. Example "255.f" - */ -INFERENCE_ENGINE_DEPRECATED("") -DECLARE_VPU_CONFIG_KEY(INPUT_NORM); - -/** - * @deprecated - * @brief The flag to specify Bias value that is added to each element of the network input. - * This option should used with be a real number. Example "0.1f" - */ -INFERENCE_ENGINE_DEPRECATED("") -DECLARE_VPU_CONFIG_KEY(INPUT_BIAS); - -/** + * @deprecated Use InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME instead. * @brief The flag for adding to the profiling information the time of obtaining a tensor. * This option should be used with values: CONFIG_VALUE(YES) or CONFIG_VALUE(NO) (default) */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME instead") DECLARE_VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME); -/** - * @deprecated The data scaling now works automatically. - */ -INFERENCE_ENGINE_DEPRECATED("The data scaling now works automatically") -DECLARE_VPU_CONFIG_KEY(NETWORK_CONFIG); - /** * @deprecated Use InputInfo::setLayout on input data from ICNNNetwork::getInputsInfo() or * Data::setLayout on output data from ICNNNetwork::getOutputsInfo() @@ -114,42 +97,29 @@ INFERENCE_ENGINE_DEPRECATED("See VPU_CONFIG_KEY(COMPUTE_LAYOUT) deprecation info DECLARE_VPU_CONFIG_VALUE(NDHWC); /** + * @deprecated Use InferenceEngine::MYRIAD_CUSTOM_LAYERS instead. * @brief This option allows to pass custom layers binding xml. * If layer is present in such an xml, it would be used during inference even if the layer is natively supported */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_CUSTOM_LAYERS instead") DECLARE_VPU_CONFIG_KEY(CUSTOM_LAYERS); /** + * @deprecated Use InferenceEngine::MYRIAD_PROTOCOL instead. * @brief This option allows to specify protocol. */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_PROTOCOL instead") DECLARE_VPU_MYRIAD_CONFIG_KEY(PROTOCOL); /** + * @deprecated Use InferenceEngine::MYRIAD_PCIE or InferenceEngine::MYRIAD_USB instead. * @brief Supported keys definition for VPU_MYRIAD_CONFIG_KEY(PROTOCOL) option. */ +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_PCIE instead") DECLARE_VPU_MYRIAD_CONFIG_VALUE(PCIE); +INFERENCE_ENGINE_DEPRECATED("Use InferenceEngine::MYRIAD_USB instead") DECLARE_VPU_MYRIAD_CONFIG_VALUE(USB); -/** - * @deprecated Use VPU_MYRIAD_CONFIG_KEY(FORCE_RESET) instead. - */ -INFERENCE_ENGINE_DEPRECATED("Use VPU_MYRIAD_CONFIG_KEY(FORCE_RESET) instead") -DECLARE_VPU_CONFIG_KEY(FORCE_RESET); - -/** - * @deprecated Use VPU_MYRIAD_CONFIG_KEY(PLATFORM) instead. - */ -INFERENCE_ENGINE_DEPRECATED("Use VPU_MYRIAD_CONFIG_KEY(PLATFORM) instead") -DECLARE_VPU_CONFIG_KEY(PLATFORM); - -/** - * @brief Supported keys definition for DECLARE_VPU_CONFIG_KEY(PLATFORM) option. - */ -INFERENCE_ENGINE_DEPRECATED("") -DECLARE_VPU_CONFIG_VALUE(2450); -INFERENCE_ENGINE_DEPRECATED("") -DECLARE_VPU_CONFIG_VALUE(2480); - } // namespace VPUConfigParams } // namespace InferenceEngine diff --git a/inference-engine/src/vpu/graph_transformer/include/vpu/parsed_config.hpp b/inference-engine/src/vpu/graph_transformer/include/vpu/parsed_config.hpp index 25259f71284..3e6f5943c07 100644 --- a/inference-engine/src/vpu/graph_transformer/include/vpu/parsed_config.hpp +++ b/inference-engine/src/vpu/graph_transformer/include/vpu/parsed_config.hpp @@ -9,7 +9,7 @@ #include #include -#include +#include #include #include diff --git a/inference-engine/src/vpu/graph_transformer/include/vpu/private_plugin_config.hpp b/inference-engine/src/vpu/graph_transformer/include/vpu/private_plugin_config.hpp index ba116109a6b..2e38475d31e 100644 --- a/inference-engine/src/vpu/graph_transformer/include/vpu/private_plugin_config.hpp +++ b/inference-engine/src/vpu/graph_transformer/include/vpu/private_plugin_config.hpp @@ -6,103 +6,109 @@ #include +#include #include namespace InferenceEngine { -namespace VPUConfigParams { // // Compilation options // -DECLARE_VPU_CONFIG_KEY(NUMBER_OF_SHAVES); -DECLARE_VPU_CONFIG_KEY(NUMBER_OF_CMX_SLICES); -DECLARE_VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB); +DECLARE_VPU_CONFIG(MYRIAD_NUMBER_OF_SHAVES); +DECLARE_VPU_CONFIG(MYRIAD_NUMBER_OF_CMX_SLICES); +DECLARE_VPU_CONFIG(MYRIAD_TILING_CMX_LIMIT_KB); -DECLARE_VPU_CONFIG_KEY(TENSOR_STRIDES); +DECLARE_VPU_CONFIG(MYRIAD_TENSOR_STRIDES); -DECLARE_VPU_CONFIG_KEY(IR_WITH_SCALES_DIRECTORY); -DECLARE_VPU_CONFIG_KEY(DETECT_NETWORK_BATCH); -DECLARE_VPU_CONFIG_KEY(COPY_OPTIMIZATION); -DECLARE_VPU_CONFIG_KEY(HW_INJECT_STAGES); -DECLARE_VPU_CONFIG_KEY(HW_POOL_CONV_MERGE); -DECLARE_VPU_CONFIG_KEY(PACK_DATA_IN_CMX); -DECLARE_VPU_CONFIG_KEY(HW_DILATION); -DECLARE_VPU_CONFIG_KEY(HW_EXTRA_SPLIT); -DECLARE_VPU_CONFIG_KEY(FORCE_DEPRECATED_CNN_CONVERSION); +DECLARE_VPU_CONFIG(MYRIAD_IR_WITH_SCALES_DIRECTORY); +DECLARE_VPU_CONFIG(MYRIAD_DETECT_NETWORK_BATCH); +DECLARE_VPU_CONFIG(MYRIAD_COPY_OPTIMIZATION); +DECLARE_VPU_CONFIG(MYRIAD_HW_INJECT_STAGES); +DECLARE_VPU_CONFIG(MYRIAD_HW_POOL_CONV_MERGE); +DECLARE_VPU_CONFIG(MYRIAD_PACK_DATA_IN_CMX); +DECLARE_VPU_CONFIG(MYRIAD_HW_DILATION); +DECLARE_VPU_CONFIG(MYRIAD_HW_EXTRA_SPLIT); +DECLARE_VPU_CONFIG(MYRIAD_FORCE_DEPRECATED_CNN_CONVERSION); -DECLARE_VPU_CONFIG_KEY(PERF_REPORT_MODE); -DECLARE_VPU_CONFIG_VALUE(PER_LAYER); -DECLARE_VPU_CONFIG_VALUE(PER_STAGE); +DECLARE_VPU_CONFIG(MYRIAD_PERF_REPORT_MODE); +DECLARE_VPU_CONFIG(MYRIAD_PER_LAYER); +DECLARE_VPU_CONFIG(MYRIAD_PER_STAGE); // // Debug options // -DECLARE_VPU_CONFIG_KEY(HW_WHITE_LIST); -DECLARE_VPU_CONFIG_KEY(HW_BLACK_LIST); +DECLARE_VPU_CONFIG(MYRIAD_HW_WHITE_LIST); +DECLARE_VPU_CONFIG(MYRIAD_HW_BLACK_LIST); -DECLARE_VPU_CONFIG_KEY(NONE_LAYERS); -DECLARE_VPU_CONFIG_KEY(IGNORE_UNKNOWN_LAYERS); +DECLARE_VPU_CONFIG(MYRIAD_NONE_LAYERS); +DECLARE_VPU_CONFIG(MYRIAD_IGNORE_UNKNOWN_LAYERS); -DECLARE_VPU_CONFIG_KEY(COMPILER_LOG_FILE_PATH); +DECLARE_VPU_CONFIG(MYRIAD_COMPILER_LOG_FILE_PATH); -DECLARE_VPU_CONFIG_KEY(DUMP_INTERNAL_GRAPH_FILE_NAME); -DECLARE_VPU_CONFIG_KEY(DUMP_INTERNAL_GRAPH_DIRECTORY); -DECLARE_VPU_CONFIG_KEY(DUMP_ALL_PASSES); +DECLARE_VPU_CONFIG(MYRIAD_DUMP_INTERNAL_GRAPH_FILE_NAME); +DECLARE_VPU_CONFIG(MYRIAD_DUMP_INTERNAL_GRAPH_DIRECTORY); +DECLARE_VPU_CONFIG(MYRIAD_DUMP_ALL_PASSES); /** * @brief Used to disable reorder passes in tests to be able to precisely set * desired layout on every stage. */ -DECLARE_VPU_CONFIG_KEY(DISABLE_REORDER); +DECLARE_VPU_CONFIG(MYRIAD_DISABLE_REORDER); /** * @brief Used to disable convert stages in tests to be able to insert * convert layer with desired precision. */ -DECLARE_VPU_CONFIG_KEY(DISABLE_CONVERT_STAGES); +DECLARE_VPU_CONFIG(MYRIAD_DISABLE_CONVERT_STAGES); /** * @brief Used to disable permute merging pass (with setting "NO") in tests to check it preserves behaviour. Default = "YES" */ -DECLARE_VPU_CONFIG_KEY(ENABLE_PERMUTE_MERGING); +DECLARE_VPU_CONFIG(MYRIAD_ENABLE_PERMUTE_MERGING); -DECLARE_VPU_CONFIG_KEY(ENABLE_REPL_WITH_SCRELU); +DECLARE_VPU_CONFIG(MYRIAD_ENABLE_REPL_WITH_SCRELU); -DECLARE_VPU_CONFIG_KEY(ENABLE_REPLACE_WITH_REDUCE_MEAN); +DECLARE_VPU_CONFIG(MYRIAD_ENABLE_REPLACE_WITH_REDUCE_MEAN); /** * @brief Used to enable Tensor Iterator unrolling to get a reference for Tensor Iterator per-layer tests. * Default is "NO". */ -DECLARE_VPU_CONFIG_KEY(ENABLE_TENSOR_ITERATOR_UNROLLING); +DECLARE_VPU_CONFIG(MYRIAD_ENABLE_TENSOR_ITERATOR_UNROLLING); /** * @brief Used to guarantee Tensor Iterator layer will remain in the network regardless of possible performance transformation. * Example of transformation: combining to RNN sequence. Needed for Tensor Iterator per-layer tests. * Default is "NO". */ -DECLARE_VPU_CONFIG_KEY(FORCE_PURE_TENSOR_ITERATOR); +DECLARE_VPU_CONFIG(MYRIAD_FORCE_PURE_TENSOR_ITERATOR); // // Myriad plugin options // -DECLARE_VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT); -DECLARE_VPU_MYRIAD_CONFIG_VALUE(POWER_FULL); -DECLARE_VPU_MYRIAD_CONFIG_VALUE(POWER_INFER); -DECLARE_VPU_MYRIAD_CONFIG_VALUE(POWER_STAGE); -DECLARE_VPU_MYRIAD_CONFIG_VALUE(POWER_STAGE_SHAVES); -DECLARE_VPU_MYRIAD_CONFIG_VALUE(POWER_STAGE_NCES); +DECLARE_VPU_CONFIG(MYRIAD_POWER_MANAGEMENT); +DECLARE_VPU_CONFIG(MYRIAD_POWER_FULL); +DECLARE_VPU_CONFIG(MYRIAD_POWER_INFER); +DECLARE_VPU_CONFIG(MYRIAD_POWER_STAGE); +DECLARE_VPU_CONFIG(MYRIAD_POWER_STAGE_SHAVES); +DECLARE_VPU_CONFIG(MYRIAD_POWER_STAGE_NCES); -DECLARE_VPU_MYRIAD_CONFIG_KEY(THROUGHPUT_STREAMS); +DECLARE_VPU_CONFIG(MYRIAD_WATCHDOG); -DECLARE_VPU_MYRIAD_CONFIG_KEY(WATCHDOG); +DECLARE_VPU_CONFIG(MYRIAD_PLUGIN_LOG_FILE_PATH); -DECLARE_VPU_MYRIAD_CONFIG_KEY(PLUGIN_LOG_FILE_PATH); +DECLARE_VPU_CONFIG(MYRIAD_DEVICE_CONNECT_TIMEOUT); -DECLARE_VPU_MYRIAD_CONFIG_KEY(DEVICE_CONNECT_TIMEOUT); +namespace VPUConfigParams { + +IE_SUPPRESS_DEPRECATED_START +// Used to update API usage in the dependent repos. +DECLARE_VPU_CONFIG_KEY(DETECT_NETWORK_BATCH); +IE_SUPPRESS_DEPRECATED_END } // namespace VPUConfigParams + } // namespace InferenceEngine diff --git a/inference-engine/src/vpu/graph_transformer/src/graph_transformer.cpp b/inference-engine/src/vpu/graph_transformer/src/graph_transformer.cpp index 8bb86477075..2164c32f6e3 100644 --- a/inference-engine/src/vpu/graph_transformer/src/graph_transformer.cpp +++ b/inference-engine/src/vpu/graph_transformer/src/graph_transformer.cpp @@ -85,28 +85,28 @@ void CompileEnv::init(Platform platform, const CompilationConfig& config, const VPU_THROW_UNLESS(g_compileEnv->config.numSHAVEs <= g_compileEnv->config.numCMXSlices, R"(Value of configuration option ("{}") must be not greater than value of configuration option ("{}"), but {} > {} are provided)", - VPU_CONFIG_KEY(NUMBER_OF_SHAVES), VPU_CONFIG_KEY(NUMBER_OF_CMX_SLICES), config.numSHAVEs, config.numCMXSlices); + ie::MYRIAD_NUMBER_OF_SHAVES, ie::MYRIAD_NUMBER_OF_CMX_SLICES, config.numSHAVEs, config.numCMXSlices); const auto numExecutors = config.numExecutors != -1 ? config.numExecutors : DefaultAllocation::numStreams(platform, config); VPU_THROW_UNLESS(numExecutors >= 1 && numExecutors <= DeviceResources::numStreams(), R"(Value of configuration option ("{}") must be in the range [{}, {}], actual is "{}")", - VPU_MYRIAD_CONFIG_KEY(THROUGHPUT_STREAMS), 1, DeviceResources::numStreams(), numExecutors); + ie::MYRIAD_THROUGHPUT_STREAMS, 1, DeviceResources::numStreams(), numExecutors); const auto numSlices = config.numCMXSlices != -1 ? config.numCMXSlices : DefaultAllocation::numSlices(platform, numExecutors); VPU_THROW_UNLESS(numSlices >= 1 && numSlices <= DeviceResources::numSlices(platform), R"(Value of configuration option ("{}") must be in the range [{}, {}], actual is "{}")", - VPU_CONFIG_KEY(NUMBER_OF_CMX_SLICES), 1, DeviceResources::numSlices(platform), numSlices); + ie::MYRIAD_NUMBER_OF_CMX_SLICES, 1, DeviceResources::numSlices(platform), numSlices); int defaultCmxLimit = DefaultAllocation::tilingCMXLimit(numSlices); const auto tilingCMXLimit = config.tilingCMXLimitKB != -1 ? std::min(config.tilingCMXLimitKB * 1024, defaultCmxLimit) : defaultCmxLimit; VPU_THROW_UNLESS(tilingCMXLimit >= 0, R"(Value of configuration option ("{}") must be greater than {}, actual is "{}")", - VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), 0, tilingCMXLimit); + ie::MYRIAD_TILING_CMX_LIMIT_KB, 0, tilingCMXLimit); const auto numShaves = config.numSHAVEs != -1 ? config.numSHAVEs : DefaultAllocation::numShaves(platform, numExecutors, numSlices); VPU_THROW_UNLESS(numShaves >= 1 && numShaves <= DeviceResources::numShaves(platform), R"(Value of configuration option ("{}") must be in the range [{}, {}], actual is "{}")", - VPU_CONFIG_KEY(NUMBER_OF_SHAVES), 1, DeviceResources::numShaves(platform), numShaves); + ie::MYRIAD_NUMBER_OF_SHAVES, 1, DeviceResources::numShaves(platform), numShaves); const auto numAllocatedShaves = numShaves * numExecutors; VPU_THROW_UNLESS(numAllocatedShaves >= 1 && numAllocatedShaves <= DeviceResources::numShaves(platform), diff --git a/inference-engine/src/vpu/graph_transformer/src/parsed_config.cpp b/inference-engine/src/vpu/graph_transformer/src/parsed_config.cpp index a3c2ac37b43..7854d0f1c44 100644 --- a/inference-engine/src/vpu/graph_transformer/src/parsed_config.cpp +++ b/inference-engine/src/vpu/graph_transformer/src/parsed_config.cpp @@ -29,55 +29,66 @@ IE_SUPPRESS_DEPRECATED_START CONFIG_KEY(CONFIG_FILE), - VPU_CONFIG_KEY(NETWORK_CONFIG), - VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), - VPU_CONFIG_KEY(HW_EXTRA_SPLIT), - VPU_CONFIG_KEY(CUSTOM_LAYERS), + ie::MYRIAD_ENABLE_HW_ACCELERATION, + ie::MYRIAD_CUSTOM_LAYERS, + ie::MYRIAD_THROUGHPUT_STREAMS, - VPU_CONFIG_KEY(INPUT_NORM), - VPU_CONFIG_KEY(INPUT_BIAS), + // + // Public deprecated + // + + VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), + VPU_CONFIG_KEY(CUSTOM_LAYERS), // // Private options // - VPU_CONFIG_KEY(NUMBER_OF_SHAVES), - VPU_CONFIG_KEY(NUMBER_OF_CMX_SLICES), - VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), + ie::MYRIAD_HW_EXTRA_SPLIT, - VPU_CONFIG_KEY(TENSOR_STRIDES), + ie::MYRIAD_NUMBER_OF_SHAVES, + ie::MYRIAD_NUMBER_OF_CMX_SLICES, + ie::MYRIAD_TILING_CMX_LIMIT_KB, - VPU_CONFIG_KEY(IR_WITH_SCALES_DIRECTORY), - VPU_CONFIG_KEY(DETECT_NETWORK_BATCH), - VPU_CONFIG_KEY(COPY_OPTIMIZATION), - VPU_CONFIG_KEY(HW_INJECT_STAGES), - VPU_CONFIG_KEY(HW_POOL_CONV_MERGE), - VPU_CONFIG_KEY(PACK_DATA_IN_CMX), - VPU_CONFIG_KEY(HW_DILATION), - VPU_CONFIG_KEY(FORCE_DEPRECATED_CNN_CONVERSION), - VPU_CONFIG_KEY(DISABLE_REORDER), - VPU_CONFIG_KEY(ENABLE_PERMUTE_MERGING), - VPU_CONFIG_KEY(ENABLE_REPL_WITH_SCRELU), - VPU_CONFIG_KEY(ENABLE_REPLACE_WITH_REDUCE_MEAN), - VPU_CONFIG_KEY(ENABLE_TENSOR_ITERATOR_UNROLLING), - VPU_CONFIG_KEY(FORCE_PURE_TENSOR_ITERATOR), - VPU_CONFIG_KEY(DISABLE_CONVERT_STAGES), + ie::MYRIAD_TENSOR_STRIDES, + + ie::MYRIAD_IR_WITH_SCALES_DIRECTORY, + ie::MYRIAD_DETECT_NETWORK_BATCH, + ie::MYRIAD_COPY_OPTIMIZATION, + ie::MYRIAD_HW_INJECT_STAGES, + ie::MYRIAD_HW_POOL_CONV_MERGE, + ie::MYRIAD_PACK_DATA_IN_CMX, + ie::MYRIAD_HW_DILATION, + ie::MYRIAD_FORCE_DEPRECATED_CNN_CONVERSION, + ie::MYRIAD_DISABLE_REORDER, + ie::MYRIAD_ENABLE_PERMUTE_MERGING, + ie::MYRIAD_ENABLE_REPL_WITH_SCRELU, + ie::MYRIAD_ENABLE_REPLACE_WITH_REDUCE_MEAN, + ie::MYRIAD_ENABLE_TENSOR_ITERATOR_UNROLLING, + ie::MYRIAD_FORCE_PURE_TENSOR_ITERATOR, + ie::MYRIAD_DISABLE_CONVERT_STAGES, // // Debug options // - VPU_CONFIG_KEY(HW_WHITE_LIST), - VPU_CONFIG_KEY(HW_BLACK_LIST), + ie::MYRIAD_HW_WHITE_LIST, + ie::MYRIAD_HW_BLACK_LIST, - VPU_CONFIG_KEY(NONE_LAYERS), - VPU_CONFIG_KEY(IGNORE_UNKNOWN_LAYERS), + ie::MYRIAD_NONE_LAYERS, + ie::MYRIAD_IGNORE_UNKNOWN_LAYERS, - VPU_CONFIG_KEY(COMPILER_LOG_FILE_PATH), + ie::MYRIAD_COMPILER_LOG_FILE_PATH, - VPU_CONFIG_KEY(DUMP_INTERNAL_GRAPH_FILE_NAME), - VPU_CONFIG_KEY(DUMP_INTERNAL_GRAPH_DIRECTORY), - VPU_CONFIG_KEY(DUMP_ALL_PASSES), + ie::MYRIAD_DUMP_INTERNAL_GRAPH_FILE_NAME, + ie::MYRIAD_DUMP_INTERNAL_GRAPH_DIRECTORY, + ie::MYRIAD_DUMP_ALL_PASSES, + + // + // Private deprecated options + // + + VPU_CONFIG_KEY(DETECT_NETWORK_BATCH), }); IE_SUPPRESS_DEPRECATED_END @@ -85,11 +96,14 @@ IE_SUPPRESS_DEPRECATED_END } const std::unordered_set& ParsedConfig::getRunTimeOptions() const { +IE_SUPPRESS_DEPRECATED_START static const std::unordered_set options = merge(ParsedConfigBase::getRunTimeOptions(), { CONFIG_KEY(PERF_COUNT), VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), - VPU_CONFIG_KEY(PERF_REPORT_MODE), + ie::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, + ie::MYRIAD_PERF_REPORT_MODE, }); +IE_SUPPRESS_DEPRECATED_END return options; } @@ -97,9 +111,9 @@ const std::unordered_set& ParsedConfig::getRunTimeOptions() const { const std::unordered_set& ParsedConfig::getDeprecatedOptions() const { IE_SUPPRESS_DEPRECATED_START static const std::unordered_set options = merge(ParsedConfigBase::getDeprecatedOptions(), { - VPU_CONFIG_KEY(INPUT_NORM), - VPU_CONFIG_KEY(INPUT_BIAS), - VPU_CONFIG_KEY(NETWORK_CONFIG), + VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), + VPU_CONFIG_KEY(CUSTOM_LAYERS), + VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), }); IE_SUPPRESS_DEPRECATED_END @@ -108,8 +122,8 @@ IE_SUPPRESS_DEPRECATED_END void ParsedConfig::parse(const std::map& config) { static const std::unordered_map perfReports { - { VPU_CONFIG_VALUE(PER_LAYER), PerfReport::PerLayer }, - { VPU_CONFIG_VALUE(PER_STAGE), PerfReport::PerStage }, + { ie::MYRIAD_PER_LAYER, PerfReport::PerLayer }, + { ie::MYRIAD_PER_STAGE, PerfReport::PerStage }, }; static const auto parseStrides = [](const std::string& src) { @@ -146,38 +160,38 @@ void ParsedConfig::parse(const std::map& config) { ParsedConfigBase::parse(config); - setOption(_compilerLogFilePath, config, VPU_CONFIG_KEY(COMPILER_LOG_FILE_PATH)); - setOption(_compileConfig.dumpInternalGraphFileName, config, VPU_CONFIG_KEY(DUMP_INTERNAL_GRAPH_FILE_NAME)); - setOption(_compileConfig.dumpInternalGraphDirectory, config, VPU_CONFIG_KEY(DUMP_INTERNAL_GRAPH_DIRECTORY)); - setOption(_compileConfig.dumpAllPasses, switches, config, VPU_CONFIG_KEY(DUMP_ALL_PASSES)); + setOption(_compilerLogFilePath, config, ie::MYRIAD_COMPILER_LOG_FILE_PATH); + setOption(_compileConfig.dumpInternalGraphFileName, config, ie::MYRIAD_DUMP_INTERNAL_GRAPH_FILE_NAME); + setOption(_compileConfig.dumpInternalGraphDirectory, config, ie::MYRIAD_DUMP_INTERNAL_GRAPH_DIRECTORY); + setOption(_compileConfig.dumpAllPasses, switches, config, ie::MYRIAD_DUMP_ALL_PASSES); - setOption(_compileConfig.detectBatch, switches, config, VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)); - setOption(_compileConfig.copyOptimization, switches, config, VPU_CONFIG_KEY(COPY_OPTIMIZATION)); - setOption(_compileConfig.packDataInCmx, switches, config, VPU_CONFIG_KEY(PACK_DATA_IN_CMX)); - setOption(_compileConfig.ignoreUnknownLayers, switches, config, VPU_CONFIG_KEY(IGNORE_UNKNOWN_LAYERS)); - setOption(_compileConfig.hwOptimization, switches, config, VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION)); - setOption(_compileConfig.hwExtraSplit, switches, config, VPU_CONFIG_KEY(HW_EXTRA_SPLIT)); - setOption(_compileConfig.injectSwOps, switches, config, VPU_CONFIG_KEY(HW_INJECT_STAGES)); - setOption(_compileConfig.mergeHwPoolToConv, switches, config, VPU_CONFIG_KEY(HW_POOL_CONV_MERGE)); - setOption(_compileConfig.hwDilation, switches, config, VPU_CONFIG_KEY(HW_DILATION)); - setOption(_compileConfig.forceDeprecatedCnnConversion, switches, config, VPU_CONFIG_KEY(FORCE_DEPRECATED_CNN_CONVERSION)); - setOption(_compileConfig.disableReorder, switches, config, VPU_CONFIG_KEY(DISABLE_REORDER)); - setOption(_compileConfig.enablePermuteMerging, switches, config, VPU_CONFIG_KEY(ENABLE_PERMUTE_MERGING)); - setOption(_compileConfig.enableReplWithSCRelu, switches, config, VPU_CONFIG_KEY(ENABLE_REPL_WITH_SCRELU)); - setOption(_compileConfig.enableReplaceWithReduceMean, switches, config, VPU_CONFIG_KEY(ENABLE_REPLACE_WITH_REDUCE_MEAN)); - setOption(_compileConfig.enableTensorIteratorUnrolling, switches, config, VPU_CONFIG_KEY(ENABLE_TENSOR_ITERATOR_UNROLLING)); - setOption(_compileConfig.forcePureTensorIterator, switches, config, VPU_CONFIG_KEY(FORCE_PURE_TENSOR_ITERATOR)); - setOption(_compileConfig.disableConvertStages, switches, config, VPU_CONFIG_KEY(DISABLE_CONVERT_STAGES)); + setOption(_compileConfig.detectBatch, switches, config, ie::MYRIAD_DETECT_NETWORK_BATCH); + setOption(_compileConfig.copyOptimization, switches, config, ie::MYRIAD_COPY_OPTIMIZATION); + setOption(_compileConfig.packDataInCmx, switches, config, ie::MYRIAD_PACK_DATA_IN_CMX); + setOption(_compileConfig.ignoreUnknownLayers, switches, config, ie::MYRIAD_IGNORE_UNKNOWN_LAYERS); + setOption(_compileConfig.hwOptimization, switches, config, ie::MYRIAD_ENABLE_HW_ACCELERATION); + setOption(_compileConfig.hwExtraSplit, switches, config, ie::MYRIAD_HW_EXTRA_SPLIT); + setOption(_compileConfig.injectSwOps, switches, config, ie::MYRIAD_HW_INJECT_STAGES); + setOption(_compileConfig.mergeHwPoolToConv, switches, config, ie::MYRIAD_HW_POOL_CONV_MERGE); + setOption(_compileConfig.hwDilation, switches, config, ie::MYRIAD_HW_DILATION); + setOption(_compileConfig.forceDeprecatedCnnConversion, switches, config, ie::MYRIAD_FORCE_DEPRECATED_CNN_CONVERSION); + setOption(_compileConfig.disableReorder, switches, config, ie::MYRIAD_DISABLE_REORDER); + setOption(_compileConfig.enablePermuteMerging, switches, config, ie::MYRIAD_ENABLE_PERMUTE_MERGING); + setOption(_compileConfig.enableReplWithSCRelu, switches, config, ie::MYRIAD_ENABLE_REPL_WITH_SCRELU); + setOption(_compileConfig.enableReplaceWithReduceMean, switches, config, ie::MYRIAD_ENABLE_REPLACE_WITH_REDUCE_MEAN); + setOption(_compileConfig.enableTensorIteratorUnrolling, switches, config, ie::MYRIAD_ENABLE_TENSOR_ITERATOR_UNROLLING); + setOption(_compileConfig.forcePureTensorIterator, switches, config, ie::MYRIAD_FORCE_PURE_TENSOR_ITERATOR); + setOption(_compileConfig.disableConvertStages, switches, config, ie::MYRIAD_DISABLE_CONVERT_STAGES); - setOption(_compileConfig.irWithVpuScalesDir, config, VPU_CONFIG_KEY(IR_WITH_SCALES_DIRECTORY)); - setOption(_compileConfig.noneLayers, config, VPU_CONFIG_KEY(NONE_LAYERS), parseStringSet); - setOption(_compileConfig.hwWhiteList, config, VPU_CONFIG_KEY(HW_WHITE_LIST), parseStringSet); - setOption(_compileConfig.hwBlackList, config, VPU_CONFIG_KEY(HW_BLACK_LIST), parseStringSet); + setOption(_compileConfig.irWithVpuScalesDir, config, ie::MYRIAD_IR_WITH_SCALES_DIRECTORY); + setOption(_compileConfig.noneLayers, config, ie::MYRIAD_NONE_LAYERS, parseStringSet); + setOption(_compileConfig.hwWhiteList, config, ie::MYRIAD_HW_WHITE_LIST, parseStringSet); + setOption(_compileConfig.hwBlackList, config, ie::MYRIAD_HW_BLACK_LIST, parseStringSet); // Priority is set to VPU configuration file over plug-in config. - setOption(_compileConfig.customLayers, config, VPU_CONFIG_KEY(CUSTOM_LAYERS)); + setOption(_compileConfig.customLayers, config, ie::MYRIAD_CUSTOM_LAYERS); if (_compileConfig.customLayers.empty()) { - setOption(_compileConfig.customLayers, config, CONFIG_KEY(CONFIG_FILE)); + setOption(_compileConfig.customLayers, config, CONFIG_KEY(CONFIG_FILE)); } auto isPositive = [](int value) { @@ -198,25 +212,27 @@ void ParsedConfig::parse(const std::map& config) { throw std::invalid_argument("Value must be positive or default(-1)."); }; - setOption(_compileConfig.numSHAVEs, config, VPU_CONFIG_KEY(NUMBER_OF_SHAVES), preprocessCompileOption); - setOption(_compileConfig.numCMXSlices, config, VPU_CONFIG_KEY(NUMBER_OF_CMX_SLICES), preprocessCompileOption); - setOption(_compileConfig.numExecutors, config, VPU_MYRIAD_CONFIG_KEY(THROUGHPUT_STREAMS), preprocessCompileOption); - setOption(_compileConfig.tilingCMXLimitKB, config, VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), preprocessCompileOption); + setOption(_compileConfig.numSHAVEs, config, ie::MYRIAD_NUMBER_OF_SHAVES, preprocessCompileOption); + setOption(_compileConfig.numCMXSlices, config, ie::MYRIAD_NUMBER_OF_CMX_SLICES, preprocessCompileOption); + setOption(_compileConfig.numExecutors, config, ie::MYRIAD_THROUGHPUT_STREAMS, preprocessCompileOption); + setOption(_compileConfig.tilingCMXLimitKB, config, ie::MYRIAD_TILING_CMX_LIMIT_KB, preprocessCompileOption); if ((_compileConfig.numSHAVEs < 0 && _compileConfig.numCMXSlices >= 0) || (_compileConfig.numSHAVEs >= 0 && _compileConfig.numCMXSlices < 0)) { THROW_IE_EXCEPTION << "You should set both option for resource management: VPU_NUMBER_OF_CMX_SLICES and VPU_NUMBER_OF_SHAVES"; } - setOption(_compileConfig.ioStrides, config, VPU_CONFIG_KEY(TENSOR_STRIDES), parseStrides); + setOption(_compileConfig.ioStrides, config, ie::MYRIAD_TENSOR_STRIDES, parseStrides); - setOption(_printReceiveTensorTime, switches, config, VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME)); - setOption(_perfCount, switches, config, CONFIG_KEY(PERF_COUNT)); - setOption(_perfReport, perfReports, config, VPU_CONFIG_KEY(PERF_REPORT_MODE)); + setOption(_printReceiveTensorTime, switches, config, ie::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME); + setOption(_perfCount, switches, config, CONFIG_KEY(PERF_COUNT)); + setOption(_perfReport, perfReports, config, ie::MYRIAD_PERF_REPORT_MODE); IE_SUPPRESS_DEPRECATED_START - setOption(_compileConfig.inputScale, config, VPU_CONFIG_KEY(INPUT_NORM), parseFloatReverse); - setOption(_compileConfig.inputBias, config, VPU_CONFIG_KEY(INPUT_BIAS), parseFloat); + setOption(_compileConfig.hwOptimization, switches, config, VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION)); + setOption(_compileConfig.customLayers, config, VPU_CONFIG_KEY(CUSTOM_LAYERS)); + setOption(_printReceiveTensorTime, switches, config, VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME)); + setOption(_compileConfig.detectBatch, switches, config, VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)); IE_SUPPRESS_DEPRECATED_END #ifndef NDEBUG diff --git a/inference-engine/src/vpu/myriad_plugin/myriad_config.cpp b/inference-engine/src/vpu/myriad_plugin/myriad_config.cpp index b3c7c33a614..cee34d06e9d 100644 --- a/inference-engine/src/vpu/myriad_plugin/myriad_config.cpp +++ b/inference-engine/src/vpu/myriad_plugin/myriad_config.cpp @@ -12,6 +12,7 @@ #include #include +#include namespace vpu { namespace MyriadPlugin { @@ -20,7 +21,6 @@ const std::unordered_set& MyriadConfig::getCompileOptions() const { IE_SUPPRESS_DEPRECATED_START static const std::unordered_set options = merge(ParsedConfig::getCompileOptions(), { VPU_MYRIAD_CONFIG_KEY(PLATFORM), - VPU_CONFIG_KEY(PLATFORM), }); IE_SUPPRESS_DEPRECATED_END @@ -32,19 +32,22 @@ IE_SUPPRESS_DEPRECATED_START static const std::unordered_set options = merge(ParsedConfig::getRunTimeOptions(), { CONFIG_KEY(DEVICE_ID), + ie::MYRIAD_ENABLE_FORCE_RESET, + + ie::MYRIAD_PROTOCOL, + ie::MYRIAD_WATCHDOG, + ie::MYRIAD_THROUGHPUT_STREAMS, + ie::MYRIAD_POWER_MANAGEMENT, + + ie::MYRIAD_PLUGIN_LOG_FILE_PATH, + ie::MYRIAD_DEVICE_CONNECT_TIMEOUT, + + ie::MYRIAD_DDR_TYPE, + + // Deprecated VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_KEY(PROTOCOL), - VPU_MYRIAD_CONFIG_KEY(WATCHDOG), - VPU_MYRIAD_CONFIG_KEY(THROUGHPUT_STREAMS), - VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), - - VPU_CONFIG_KEY(FORCE_RESET), - VPU_CONFIG_KEY(PLATFORM), - - VPU_MYRIAD_CONFIG_KEY(PLUGIN_LOG_FILE_PATH), - VPU_MYRIAD_CONFIG_KEY(DEVICE_CONNECT_TIMEOUT), - VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), }); IE_SUPPRESS_DEPRECATED_END @@ -55,8 +58,10 @@ IE_SUPPRESS_DEPRECATED_END const std::unordered_set& MyriadConfig::getDeprecatedOptions() const { IE_SUPPRESS_DEPRECATED_START static const std::unordered_set options = merge(ParsedConfig::getDeprecatedOptions(), { - VPU_CONFIG_KEY(FORCE_RESET), - VPU_CONFIG_KEY(PLATFORM), + VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), + VPU_MYRIAD_CONFIG_KEY(PLATFORM), + VPU_MYRIAD_CONFIG_KEY(PROTOCOL), + VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), }); IE_SUPPRESS_DEPRECATED_END @@ -64,24 +69,32 @@ IE_SUPPRESS_DEPRECATED_END } void MyriadConfig::parse(const std::map& config) { - static const std::unordered_map platforms = { - { VPU_MYRIAD_CONFIG_VALUE(2450), NC_MYRIAD_2 }, - { VPU_MYRIAD_CONFIG_VALUE(2480), NC_MYRIAD_X }, - { std::string(), NC_ANY_PLATFORM } +IE_SUPPRESS_DEPRECATED_START + static const std::unordered_map platformsDeprecated = { + { VPU_MYRIAD_CONFIG_VALUE(2450), NC_MYRIAD_2 }, + { VPU_MYRIAD_CONFIG_VALUE(2480), NC_MYRIAD_X }, + { std::string(), NC_ANY_PLATFORM } }; -IE_SUPPRESS_DEPRECATED_START - static const std::unordered_map platformsDepr = { - { VPU_CONFIG_VALUE(2450), NC_MYRIAD_2 }, - { VPU_CONFIG_VALUE(2480), NC_MYRIAD_X }, - { std::string(), NC_ANY_PLATFORM } + static const std::unordered_map protocolsDeprecated = { + { VPU_MYRIAD_CONFIG_VALUE(USB), NC_USB}, + { VPU_MYRIAD_CONFIG_VALUE(PCIE), NC_PCIE}, + { std::string(), NC_ANY_PROTOCOL} + }; + + static const std::unordered_map memoryTypesDeprecated = { + { VPU_MYRIAD_CONFIG_VALUE(DDR_AUTO), MovidiusDdrType::AUTO }, + { VPU_MYRIAD_CONFIG_VALUE(MICRON_2GB), MovidiusDdrType::MICRON_2GB }, + { VPU_MYRIAD_CONFIG_VALUE(SAMSUNG_2GB), MovidiusDdrType::SAMSUNG_2GB }, + { VPU_MYRIAD_CONFIG_VALUE(HYNIX_2GB), MovidiusDdrType::HYNIX_2GB }, + { VPU_MYRIAD_CONFIG_VALUE(MICRON_1GB), MovidiusDdrType::MICRON_1GB } }; IE_SUPPRESS_DEPRECATED_END static const std::unordered_map protocols = { - { VPU_MYRIAD_CONFIG_VALUE(USB), NC_USB}, - { VPU_MYRIAD_CONFIG_VALUE(PCIE), NC_PCIE}, - { std::string(), NC_ANY_PROTOCOL} + { ie::MYRIAD_USB, NC_USB}, + { ie::MYRIAD_PCIE, NC_PCIE}, + { std::string(), NC_ANY_PROTOCOL} }; static const std::unordered_map watchdogIntervals = { @@ -90,36 +103,37 @@ IE_SUPPRESS_DEPRECATED_END }; static const std::unordered_map powerConfigs = { - { VPU_MYRIAD_CONFIG_VALUE(POWER_FULL), PowerConfig::FULL }, - { VPU_MYRIAD_CONFIG_VALUE(POWER_INFER), PowerConfig::INFER }, - { VPU_MYRIAD_CONFIG_VALUE(POWER_STAGE), PowerConfig::STAGE }, - { VPU_MYRIAD_CONFIG_VALUE(POWER_STAGE_SHAVES), PowerConfig::STAGE_SHAVES }, - { VPU_MYRIAD_CONFIG_VALUE(POWER_STAGE_NCES), PowerConfig::STAGE_NCES }, + { ie::MYRIAD_POWER_FULL, PowerConfig::FULL }, + { ie::MYRIAD_POWER_INFER, PowerConfig::INFER }, + { ie::MYRIAD_POWER_STAGE, PowerConfig::STAGE }, + { ie::MYRIAD_POWER_STAGE_SHAVES, PowerConfig::STAGE_SHAVES }, + { ie::MYRIAD_POWER_STAGE_NCES, PowerConfig::STAGE_NCES }, }; static const std::unordered_map memoryTypes = { - { VPU_MYRIAD_CONFIG_VALUE(DDR_AUTO), MovidiusDdrType::AUTO }, - { VPU_MYRIAD_CONFIG_VALUE(MICRON_2GB), MovidiusDdrType::MICRON_2GB }, - { VPU_MYRIAD_CONFIG_VALUE(SAMSUNG_2GB), MovidiusDdrType::SAMSUNG_2GB }, - { VPU_MYRIAD_CONFIG_VALUE(HYNIX_2GB), MovidiusDdrType::HYNIX_2GB }, - { VPU_MYRIAD_CONFIG_VALUE(MICRON_1GB), MovidiusDdrType::MICRON_1GB } + { ie::MYRIAD_DDR_AUTO, MovidiusDdrType::AUTO }, + { ie::MYRIAD_DDR_MICRON_2GB, MovidiusDdrType::MICRON_2GB }, + { ie::MYRIAD_DDR_SAMSUNG_2GB, MovidiusDdrType::SAMSUNG_2GB }, + { ie::MYRIAD_DDR_HYNIX_2GB, MovidiusDdrType::HYNIX_2GB }, + { ie::MYRIAD_DDR_MICRON_1GB, MovidiusDdrType::MICRON_1GB } }; ParsedConfig::parse(config); - setOption(_pluginLogFilePath, config, VPU_MYRIAD_CONFIG_KEY(PLUGIN_LOG_FILE_PATH)); - setOption(_deviceName, config, CONFIG_KEY(DEVICE_ID)); - setOption(_forceReset, switches, config, VPU_MYRIAD_CONFIG_KEY(FORCE_RESET)); - setOption(_platform, platforms, config, VPU_MYRIAD_CONFIG_KEY(PLATFORM)); - setOption(_protocol, protocols, config, VPU_MYRIAD_CONFIG_KEY(PROTOCOL)); - setOption(_watchdogInterval, watchdogIntervals, config, VPU_MYRIAD_CONFIG_KEY(WATCHDOG)); - setOption(_deviceConnectTimeout, config, VPU_MYRIAD_CONFIG_KEY(DEVICE_CONNECT_TIMEOUT), parseSeconds); - setOption(_powerConfig, powerConfigs, config, VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT)); - setOption(_memoryType, memoryTypes, config, VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE)); + setOption(_pluginLogFilePath, config, ie::MYRIAD_PLUGIN_LOG_FILE_PATH); + setOption(_deviceName, config, CONFIG_KEY(DEVICE_ID)); + setOption(_forceReset, switches, config, ie::MYRIAD_ENABLE_FORCE_RESET); + setOption(_protocol, protocols, config, ie::MYRIAD_PROTOCOL); + setOption(_watchdogInterval, watchdogIntervals, config, ie::MYRIAD_WATCHDOG); + setOption(_deviceConnectTimeout, config, ie::MYRIAD_DEVICE_CONNECT_TIMEOUT, parseSeconds); + setOption(_powerConfig, powerConfigs, config, ie::MYRIAD_POWER_MANAGEMENT); + setOption(_memoryType, memoryTypes, config, ie::MYRIAD_DDR_TYPE); IE_SUPPRESS_DEPRECATED_START - setOption(_forceReset, switches, config, VPU_CONFIG_KEY(FORCE_RESET)); - setOption(_platform, platformsDepr, config, VPU_CONFIG_KEY(PLATFORM)); + setOption(_forceReset, switches, config, VPU_MYRIAD_CONFIG_KEY(FORCE_RESET)); + setOption(_platform, platformsDeprecated, config, VPU_MYRIAD_CONFIG_KEY(PLATFORM)); + setOption(_protocol, protocolsDeprecated, config, VPU_MYRIAD_CONFIG_KEY(PROTOCOL)); + setOption(_memoryType, memoryTypesDeprecated, config, VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE)); IE_SUPPRESS_DEPRECATED_END #ifndef NDEBUG diff --git a/inference-engine/src/vpu/myriad_plugin/myriad_metrics.cpp b/inference-engine/src/vpu/myriad_plugin/myriad_metrics.cpp index a3a1ab70b09..720586d6b1b 100644 --- a/inference-engine/src/vpu/myriad_plugin/myriad_metrics.cpp +++ b/inference-engine/src/vpu/myriad_plugin/myriad_metrics.cpp @@ -9,8 +9,9 @@ #include using namespace vpu::MyriadPlugin; -using namespace InferenceEngine::VPUConfigParams; -using namespace InferenceEngine::PluginConfigParams; +using namespace InferenceEngine; +using namespace VPUConfigParams; +using namespace PluginConfigParams; //------------------------------------------------------------------------------ // Implementation of methods of class MyriadMetrics @@ -29,16 +30,23 @@ MyriadMetrics::MyriadMetrics() { IE_SUPPRESS_DEPRECATED_START _supportedConfigKeys = { + MYRIAD_ENABLE_HW_ACCELERATION, + MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, + MYRIAD_CUSTOM_LAYERS, + MYRIAD_ENABLE_FORCE_RESET, + + // deprecated KEY_VPU_HW_STAGES_OPTIMIZATION, - KEY_LOG_LEVEL, KEY_VPU_PRINT_RECEIVE_TENSOR_TIME, KEY_VPU_CUSTOM_LAYERS, KEY_VPU_MYRIAD_FORCE_RESET, KEY_VPU_MYRIAD_PLATFORM, - KEY_EXCLUSIVE_ASYNC_REQUESTS, - KEY_PERF_COUNT, - KEY_CONFIG_FILE, - KEY_DEVICE_ID + + CONFIG_KEY(LOG_LEVEL), + CONFIG_KEY(EXCLUSIVE_ASYNC_REQUESTS), + CONFIG_KEY(PERF_COUNT), + CONFIG_KEY(CONFIG_FILE), + CONFIG_KEY(DEVICE_ID) }; IE_SUPPRESS_DEPRECATED_END @@ -108,7 +116,7 @@ const std::unordered_set& MyriadMetrics::OptimizationCapabilities() RangeType MyriadMetrics::RangeForAsyncInferRequests( const std::map& config) const { - auto throughput_streams_str = config.find(KEY_VPU_MYRIAD_THROUGHPUT_STREAMS); + auto throughput_streams_str = config.find(ie::MYRIAD_THROUGHPUT_STREAMS); if (throughput_streams_str != config.end()) { try { int throughput_streams = std::stoi(throughput_streams_str->second); @@ -117,7 +125,7 @@ RangeType MyriadMetrics::RangeForAsyncInferRequests( } } catch(...) { - THROW_IE_EXCEPTION << "Invalid config value for VPU_MYRIAD_THROUGHPUT_STREAMS, can't cast to int"; + THROW_IE_EXCEPTION << "Invalid config value for MYRIAD_THROUGHPUT_STREAMS, can't cast to int"; } } diff --git a/inference-engine/src/vpu/myriad_plugin/myriad_plugin.cpp b/inference-engine/src/vpu/myriad_plugin/myriad_plugin.cpp index 28e838b30e0..fcae13b3b3b 100644 --- a/inference-engine/src/vpu/myriad_plugin/myriad_plugin.cpp +++ b/inference-engine/src/vpu/myriad_plugin/myriad_plugin.cpp @@ -130,18 +130,27 @@ Engine::Engine(std::shared_ptr mvnc) : _pluginName = "MYRIAD"; +IE_SUPPRESS_DEPRECATED_START _config = { - { KEY_VPU_HW_STAGES_OPTIMIZATION, "ON" }, - { KEY_LOG_LEVEL, "LOG_NONE" }, - { KEY_VPU_PRINT_RECEIVE_TENSOR_TIME, "OFF" }, + { MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES) }, + { MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, CONFIG_VALUE(NO) }, + { MYRIAD_CUSTOM_LAYERS, "" }, + { MYRIAD_ENABLE_FORCE_RESET, CONFIG_VALUE(NO) }, + + // Deprecated + { KEY_VPU_HW_STAGES_OPTIMIZATION, CONFIG_VALUE(YES) }, + { KEY_VPU_PRINT_RECEIVE_TENSOR_TIME, CONFIG_VALUE(NO) }, { KEY_VPU_CUSTOM_LAYERS, "" }, - { KEY_VPU_MYRIAD_FORCE_RESET, "OFF" }, + { KEY_VPU_MYRIAD_FORCE_RESET, CONFIG_VALUE(NO) }, { KEY_VPU_MYRIAD_PLATFORM, "" }, - { KEY_EXCLUSIVE_ASYNC_REQUESTS, "OFF" }, - { KEY_PERF_COUNT, "OFF" }, + + { KEY_LOG_LEVEL, CONFIG_VALUE(LOG_NONE) }, + { KEY_EXCLUSIVE_ASYNC_REQUESTS, CONFIG_VALUE(NO) }, + { KEY_PERF_COUNT, CONFIG_VALUE(NO) }, { KEY_CONFIG_FILE, "" }, { KEY_DEVICE_ID, "" }, }; +IE_SUPPRESS_DEPRECATED_END } InferenceEngine::ExecutableNetwork Engine::ImportNetwork( diff --git a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/config.cpp b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/config.cpp index b4d0b0b6563..9065562f5ce 100644 --- a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/config.cpp +++ b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/config.cpp @@ -14,8 +14,8 @@ namespace { }; const std::vector> Configs = { - {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(YES)}}, - {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(NO)}}, + {{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, CONFIG_VALUE(YES)}}, + {{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, CONFIG_VALUE(NO)}}, {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_NONE)}}, {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_ERROR)}}, @@ -24,15 +24,32 @@ namespace { {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_DEBUG)}}, {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_TRACE)}}, + {{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES)}}, + {{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(NO)}}, + + {{InferenceEngine::MYRIAD_TILING_CMX_LIMIT_KB, "-1"}}, + {{InferenceEngine::MYRIAD_TILING_CMX_LIMIT_KB, "0"}}, + {{InferenceEngine::MYRIAD_TILING_CMX_LIMIT_KB, "10"}}, + + {{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, CONFIG_VALUE(YES)}}, + {{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, CONFIG_VALUE(NO)}}, + {{InferenceEngine::MYRIAD_PROTOCOL, InferenceEngine::MYRIAD_USB}}, + {{InferenceEngine::MYRIAD_PROTOCOL, InferenceEngine::MYRIAD_PCIE}}, + + {{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "1"}}, + {{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "2"}}, + {{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "3"}}, + + // Deprecated + {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(YES)}}, + {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(NO)}}, + {{VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES)}}, {{VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(NO)}}, - {{VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), "-1"}}, - {{VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), "0"}}, - {{VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), "10"}}, - {{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), CONFIG_VALUE(YES)}}, {{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), CONFIG_VALUE(NO)}}, + {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(USB)}}, {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(PCIE)}}, @@ -43,6 +60,10 @@ namespace { const std::vector> MultiConfigs = { {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, {CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_DEBUG)}}, + {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES)}}, + + // Deprecated {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES)}} }; @@ -62,6 +83,26 @@ namespace { CorrectConfigTests::getTestCaseName); const std::vector> inconfigs = { + {{InferenceEngine::MYRIAD_PROTOCOL, "BLUETOOTH"}}, + {{InferenceEngine::MYRIAD_PROTOCOL, "LAN"}}, + + {{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, "ON"}}, + {{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, "OFF"}}, + + {{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, "ON"}}, + {{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, "OFF"}}, + + {{CONFIG_KEY(LOG_LEVEL), "VERBOSE"}}, + + {{InferenceEngine::MYRIAD_TILING_CMX_LIMIT_KB, "-10"}}, + + {{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, "ON"}}, + {{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, "OFF"}}, + + {{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "Two"}}, + {{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "SINGLE"}}, + + // Deprecated {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), "BLUETOOTH"}}, {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), "LAN"}}, @@ -71,29 +112,30 @@ namespace { {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), "ON"}}, {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), "OFF"}}, - {{CONFIG_KEY(LOG_LEVEL), "VERBOSE"}}, + {{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), "ON"}}, + {{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), "OFF"}}, {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "-1"}}, {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "0"}}, {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "1"}}, - - {{VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), "-10"}}, - - {{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), "ON"}}, - {{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), "OFF"}} }; const std::vector> multiinconfigs = { {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, - {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), "ON"}}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, "ON"}}, {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, {CONFIG_KEY(LOG_LEVEL), "VERBOSE"}}, + + // Deprecated + {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, + {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), "ON"}}, + {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, {VPU_MYRIAD_CONFIG_KEY(PLATFORM), "-1"}}, {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, {VPU_MYRIAD_CONFIG_KEY(PLATFORM), "0"}}, {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, - {VPU_MYRIAD_CONFIG_KEY(PLATFORM), "1"}} + {VPU_MYRIAD_CONFIG_KEY(PLATFORM), "1"}}, }; INSTANTIATE_TEST_CASE_P(smoke_BehaviorTests, IncorrectConfigTests, @@ -160,4 +202,4 @@ namespace { ::testing::Values(CommonTestUtils::DEVICE_MULTI), ::testing::ValuesIn(multiconf)), CorrectConfigAPITests::getTestCaseName); -} // namespace \ No newline at end of file +} // namespace diff --git a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/infer_request_config.cpp b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/infer_request_config.cpp index 11d108797f6..589fb9e61a6 100644 --- a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/infer_request_config.cpp +++ b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/infer_request_config.cpp @@ -23,8 +23,8 @@ namespace { const std::vector> inferConfigs = { {}, - {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(YES)}}, - {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(NO)}}, + {{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, CONFIG_VALUE(YES)}}, + {{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, CONFIG_VALUE(NO)}}, {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_NONE)}}, {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_ERROR)}}, @@ -33,22 +33,41 @@ namespace { {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_DEBUG)}}, {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_TRACE)}}, - {{VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), "-1"}}, - {{VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), "0"}}, - {{VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB), "1"}}, + {{InferenceEngine::MYRIAD_TILING_CMX_LIMIT_KB, "-1"}}, + {{InferenceEngine::MYRIAD_TILING_CMX_LIMIT_KB, "0"}}, + {{InferenceEngine::MYRIAD_TILING_CMX_LIMIT_KB, "1"}}, + + {{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES)}}, + {{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(NO)}}, + + {{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, CONFIG_VALUE(YES)}}, + {{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, CONFIG_VALUE(NO)}}, + + {{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "1"}}, + {{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "2"}}, + {{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "3"}}, + + + // Deprecated + {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(YES)}}, + {{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(NO)}}, {{VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES)}}, {{VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(NO)}}, {{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), CONFIG_VALUE(YES)}}, - {{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), CONFIG_VALUE(NO)}} + {{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), CONFIG_VALUE(NO)}}, }; const std::vector> inferMultiConfigs = { {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, - {CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_DEBUG)}}, + {CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_DEBUG)}}, {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, - {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES)}} + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES)}}, + + // Deprecated + {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}, + {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES)}}, }; INSTANTIATE_TEST_CASE_P(smoke_BehaviorTests, InferConfigTests, diff --git a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/eltwise.cpp b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/eltwise.cpp index 304c187eb4a..69de9fadfc6 100644 --- a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/eltwise.cpp +++ b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/eltwise.cpp @@ -48,9 +48,9 @@ std::vector eltwiseOpTypes = { Config getConfig() { Config config; - config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); if (CommonTestUtils::vpu::CheckMyriad2()) { - config[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(YES); + config[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(YES); } return config; } diff --git a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/nonzero.cpp b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/nonzero.cpp index 0043a135b9d..97f2553a468 100644 --- a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/nonzero.cpp +++ b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/nonzero.cpp @@ -18,9 +18,9 @@ namespace { ConfigMap getConfig() { ConfigMap config; - config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); if (CommonTestUtils::vpu::CheckMyriad2()) { - config[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(YES); + config[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(YES); } return config; } diff --git a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/strided_slice.cpp b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/strided_slice.cpp index 8edea2d41d2..be67147e396 100644 --- a/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/strided_slice.cpp +++ b/inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/strided_slice.cpp @@ -43,7 +43,7 @@ std::vector precisions = { Config getConfig() { Config config; if (CommonTestUtils::vpu::CheckMyriad2()) { - config[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(YES); + config[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(YES); } return config; } diff --git a/inference-engine/tests/functional/plugin/myriad/single_layer_tests/out_shape_of_reshape.cpp b/inference-engine/tests/functional/plugin/myriad/single_layer_tests/out_shape_of_reshape.cpp index 16977dea745..4c96b5c700f 100644 --- a/inference-engine/tests/functional/plugin/myriad/single_layer_tests/out_shape_of_reshape.cpp +++ b/inference-engine/tests/functional/plugin/myriad/single_layer_tests/out_shape_of_reshape.cpp @@ -54,8 +54,8 @@ public: protected: void SetUp() override { SetRefMode(LayerTestsUtils::RefMode::INTERPRETER); - configuration[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); - configuration[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(YES); + configuration[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); + configuration[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(YES); OutShapeOfReshapeParam shapesParam; std::tie(shapesParam, targetDevice) = this->GetParam(); diff --git a/inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_broadcast.cpp b/inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_broadcast.cpp index 586798d4a9b..e24625aafd0 100644 --- a/inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_broadcast.cpp +++ b/inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_broadcast.cpp @@ -56,7 +56,7 @@ public: protected: void SetUp() override { SetRefMode(LayerTestsUtils::RefMode::INTERPRETER); - configuration[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + configuration[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); StaticShapeBroadcastParam shapes; std::tie(shapes, inPrc, targetDevice) = this->GetParam(); diff --git a/inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_nonzero.cpp b/inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_nonzero.cpp index b3e22020d13..89ed4380350 100644 --- a/inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_nonzero.cpp +++ b/inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_nonzero.cpp @@ -45,8 +45,8 @@ public: protected: void SetUp() override { SetRefMode(LayerTestsUtils::RefMode::INTERPRETER); - configuration[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); - configuration[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(YES); + configuration[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); + configuration[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(YES); InferenceEngine::SizeVector inputShape; std::tie(inputShape, inPrc, targetDevice) = this->GetParam(); diff --git a/inference-engine/tests/functional/plugin/myriad/subgraph_tests/dsr_tests_common.hpp b/inference-engine/tests/functional/plugin/myriad/subgraph_tests/dsr_tests_common.hpp index 2c97e7a8cc5..19b3f590b66 100644 --- a/inference-engine/tests/functional/plugin/myriad/subgraph_tests/dsr_tests_common.hpp +++ b/inference-engine/tests/functional/plugin/myriad/subgraph_tests/dsr_tests_common.hpp @@ -68,9 +68,9 @@ protected: void SetUp() override { SetRefMode(LayerTestsUtils::RefMode::CONSTANT_FOLDING); - configuration[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + configuration[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); if (CommonTestUtils::vpu::CheckMyriad2()) { - configuration[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(YES); + configuration[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(YES); } const auto testedOp = createTestedOp(); diff --git a/inference-engine/tests/functional/plugin/myriad/subgraph_tests/nonzero_broadcast.cpp b/inference-engine/tests/functional/plugin/myriad/subgraph_tests/nonzero_broadcast.cpp index 44ed9b44316..1f47cbb2f26 100644 --- a/inference-engine/tests/functional/plugin/myriad/subgraph_tests/nonzero_broadcast.cpp +++ b/inference-engine/tests/functional/plugin/myriad/subgraph_tests/nonzero_broadcast.cpp @@ -23,10 +23,10 @@ class NonZero_Broadcast : public testing::WithParamInterface MyriadProtocolTests::getConfigForProtocol(con switch (protocol) { case NC_ANY_PROTOCOL : return {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_INFO)}, - {VPU_MYRIAD_CONFIG_KEY(PROTOCOL), ""}}; + {InferenceEngine::MYRIAD_PROTOCOL, ""}}; case NC_USB: return {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_INFO)}, - {VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(USB)}}; + {InferenceEngine::MYRIAD_PROTOCOL, InferenceEngine::MYRIAD_USB}}; case NC_PCIE: return {{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_INFO)}, - {VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(PCIE)}}; + {InferenceEngine::MYRIAD_PROTOCOL, InferenceEngine::MYRIAD_PCIE}}; default: return {}; } diff --git a/inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_boot_tests.cpp b/inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_boot_tests.cpp index baa6ac1a242..558bf39a1e8 100644 --- a/inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_boot_tests.cpp +++ b/inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_boot_tests.cpp @@ -65,7 +65,7 @@ TEST_P(MYRIADBoot, DISABLED_ConnectToAlreadyBootedDevice) { CNNNetwork network = ie.ReadNetwork(GetParam().model_xml_str, Blob::CPtr()); ExecutableNetwork net = ie.LoadNetwork(network, GetParam().device, { {KEY_LOG_LEVEL, LOG_DEBUG}, - {KEY_VPU_MYRIAD_WATCHDOG, NO} }); + {InferenceEngine::MYRIAD_WATCHDOG, NO} }); ASSERT_EQ(getAmountOfBootedDevices(), 1); } @@ -85,7 +85,7 @@ TEST_P(MYRIADBoot, DISABLED_OpenNotBootedDevice) { CNNNetwork network = ie.ReadNetwork(GetParam().model_xml_str, Blob::CPtr()); ExecutableNetwork net = ie.LoadNetwork(network, GetParam().device, { {KEY_LOG_LEVEL, LOG_DEBUG}, - {KEY_VPU_MYRIAD_WATCHDOG, NO} }); + {InferenceEngine::MYRIAD_WATCHDOG, NO} }); ASSERT_EQ(getAmountOfBootedDevices(), 2); } diff --git a/inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_watchdog_tests.cpp b/inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_watchdog_tests.cpp index f480493b911..bfb729903b6 100644 --- a/inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_watchdog_tests.cpp +++ b/inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_watchdog_tests.cpp @@ -224,7 +224,7 @@ TEST_P(MYRIADWatchdog, canTurnoffWatchDogViaConfig) { ctime = Time::now(); ret = core.LoadNetwork(network, GetParam().device, { {KEY_LOG_LEVEL, LOG_INFO}, - {KEY_VPU_MYRIAD_WATCHDOG, NO}}); + {InferenceEngine::MYRIAD_WATCHDOG, NO}}); ASSERT_BOOTED_DEVICES_ONE_MORE(); diff --git a/inference-engine/tests_deprecated/behavior/vpu/shared_tests_instances/plugin_tests/vpu_test_data.hpp b/inference-engine/tests_deprecated/behavior/vpu/shared_tests_instances/plugin_tests/vpu_test_data.hpp index 78dc9daae1d..dab2e673dee 100644 --- a/inference-engine/tests_deprecated/behavior/vpu/shared_tests_instances/plugin_tests/vpu_test_data.hpp +++ b/inference-engine/tests_deprecated/behavior/vpu/shared_tests_instances/plugin_tests/vpu_test_data.hpp @@ -77,16 +77,20 @@ const BehTestParams allUnSupportedValues[] = { }; const std::vector deviceSpecificConfigurations = { - BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(USB)}}), - BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(PCIE)}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_PROTOCOL, InferenceEngine::MYRIAD_USB}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_PROTOCOL, InferenceEngine::MYRIAD_PCIE}}), + // Deprecated BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2450)}}), BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2480)}}), + + BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(USB)}}), + BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(PCIE)}}), }; const std::vector deviceAgnosticConfigurations = { - BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(YES)}}), - BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(NO)}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, CONFIG_VALUE(YES)}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, CONFIG_VALUE(NO)}}), BEH_MYRIAD.withConfig({{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_NONE)}}), BEH_MYRIAD.withConfig({{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_ERROR)}}), @@ -95,16 +99,39 @@ const std::vector deviceAgnosticConfigurations = { BEH_MYRIAD.withConfig({{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_DEBUG)}}), BEH_MYRIAD.withConfig({{CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_TRACE)}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES)}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(NO)}}), + + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, CONFIG_VALUE(YES)}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, CONFIG_VALUE(NO)}}), + + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "1"}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "2"}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "3"}}), + + + BEH_MULTI_CONFIG.withConfig({ + {MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, + {CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_DEBUG)} + }), + BEH_MULTI_CONFIG.withConfig({ + {MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES)} + }), + + // Please do not use other types of DDR in tests with a real device, because it may hang. + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_DDR_TYPE, InferenceEngine::MYRIAD_DDR_AUTO}}), + + // Deprecated + BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(YES)}}), + BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(NO)}}), + BEH_MYRIAD.withConfig({{VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES)}}), BEH_MYRIAD.withConfig({{VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(NO)}}), BEH_MYRIAD.withConfig({{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), CONFIG_VALUE(YES)}}), BEH_MYRIAD.withConfig({{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), CONFIG_VALUE(NO)}}), - BEH_MULTI_CONFIG.withConfig({ - {MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, - {CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_DEBUG)} - }), BEH_MULTI_CONFIG.withConfig({ {MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES)} @@ -121,6 +148,32 @@ const std::vector withCorrectConfValuesNetworkOnly = { }; const BehTestParams withIncorrectConfValues[] = { + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_PROTOCOL, "BLUETOOTH"}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_PROTOCOL, "LAN"}}), + + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, "ON"}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, "OFF"}}), + + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, "ON"}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, "OFF"}}), + + BEH_MYRIAD.withConfig({{CONFIG_KEY(LOG_LEVEL), "VERBOSE"}}), + + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, "ON"}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, "OFF"}}), + + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "Single"}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "TWO"}}), + + BEH_MULTI_CONFIG.withConfig({{MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION,"ON"}}), + BEH_MULTI_CONFIG.withConfig({{MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, + {CONFIG_KEY(LOG_LEVEL), "VERBOSE"}}), + + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_DDR_TYPE, "-1"}}), + BEH_MYRIAD.withConfig({{InferenceEngine::MYRIAD_DDR_TYPE, "MICRON"}}), + + // Deprecated BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), "BLUETOOTH"}}), BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), "LAN"}}), @@ -130,28 +183,25 @@ const BehTestParams withIncorrectConfValues[] = { BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), "ON"}}), BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), "OFF"}}), - BEH_MYRIAD.withConfig({{CONFIG_KEY(LOG_LEVEL), "VERBOSE"}}), - - BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "-1"}}), - BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "0"}}), - BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "1"}}), - BEH_MYRIAD.withConfig({{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), "ON"}}), BEH_MYRIAD.withConfig({{VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), "OFF"}}), BEH_MULTI_CONFIG.withConfig({{MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION),"ON"}}), - BEH_MULTI_CONFIG.withConfig({{MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, - {CONFIG_KEY(LOG_LEVEL), "VERBOSE"}}), + + BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), "-1"}}), + BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), "MICRON"}}), + + BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "-1"}}), + BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "0"}}), + BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "1"}}), + BEH_MULTI_CONFIG.withConfig({{MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, {VPU_MYRIAD_CONFIG_KEY(PLATFORM), "-1"}}), BEH_MULTI_CONFIG.withConfig({{MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, {VPU_MYRIAD_CONFIG_KEY(PLATFORM), "0"}}), BEH_MULTI_CONFIG.withConfig({{MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "MYRIAD"}, {VPU_MYRIAD_CONFIG_KEY(PLATFORM), "1"}}), - - BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), "-1"}}), - BEH_MYRIAD.withConfig({{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), "MICRON"}}), }; const BehTestParams withIncorrectConfKeys[] = { diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_CTCDecoder_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_CTCDecoder_test.hpp index ee7cc3895dd..f366fbd8f46 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_CTCDecoder_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_CTCDecoder_test.hpp @@ -95,7 +95,7 @@ TEST_P(myriadCTCDecoderLayerTests_smoke, CTCGreedyDecoder) { GTEST_SKIP() << "Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; const auto inputTensors = IN_OUT_desc{{dims.c, dims.h, dims.w}, {dims.h, dims.c}}; const auto outputTensors = IN_OUT_desc{{1, 1, dims.h, dims.c}}; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_bias_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_bias_test.hpp index c35dd523eb5..6aa5110b432 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_bias_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_bias_test.hpp @@ -93,7 +93,7 @@ class myriadLayersTestsBias_smoke: public myriadLayersTests_nightly, }; TEST_P(myriadLayersTestsBias_smoke, TestsBias) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); auto input_dim = GetParam(); InferenceEngine::SizeVector input_dim1; auto dims = input_dim.size(); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_blob_test.cpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_blob_test.cpp index 78adbd02a3a..79699abfe40 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_blob_test.cpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_blob_test.cpp @@ -46,7 +46,7 @@ TEST_P(myriadBlobTests_smoke, CanGetSameBlobsOnSameIR) { StatusCode st; ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, _cnnNetwork, - { {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), HWConfigValue } }, &_resp)); + { {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, HWConfigValue } }, &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; std::stringstream modelFilenameStream; modelFilenameStream << "spltConvConcat" << i << ".blob"; @@ -160,17 +160,12 @@ TEST_F(myriadConfigsWithBlobImportTests_smoke, TryingToSetCompileOptionPrintsWar ASSERT_EQ(StatusCode::OK, _exeNetwork->Export(modelFilenameStream.str(), &_resp)) << _resp.msg; - std::map config = { {VPU_CONFIG_KEY(COPY_OPTIMIZATION), CONFIG_VALUE(YES)}, - {VPU_CONFIG_KEY(IGNORE_UNKNOWN_LAYERS), CONFIG_VALUE(YES)}, - {VPU_CONFIG_KEY(NONE_LAYERS), CONFIG_VALUE(YES)}, - {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES)}, - {VPU_CONFIG_KEY(NUMBER_OF_SHAVES), std::to_string(10)}, - {VPU_CONFIG_KEY(NUMBER_OF_CMX_SLICES), std::to_string(10)} }; - - IE_SUPPRESS_DEPRECATED_START - config[VPU_CONFIG_KEY(INPUT_NORM)] = std::to_string(1.f); - config[VPU_CONFIG_KEY(INPUT_BIAS)] = std::to_string(1.f); - IE_SUPPRESS_DEPRECATED_START + std::map config = { {InferenceEngine::MYRIAD_COPY_OPTIMIZATION, CONFIG_VALUE(YES)}, + {InferenceEngine::MYRIAD_IGNORE_UNKNOWN_LAYERS, CONFIG_VALUE(YES)}, + {InferenceEngine::MYRIAD_NONE_LAYERS, CONFIG_VALUE(YES)}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES)}, + {InferenceEngine::MYRIAD_NUMBER_OF_SHAVES, std::to_string(10)}, + {InferenceEngine::MYRIAD_NUMBER_OF_CMX_SLICES, std::to_string(10)} }; InferenceEngine::IExecutableNetwork::Ptr importedNetworkPtr; ASSERT_EQ(StatusCode::OK, _vpuPluginPtr->ImportNetwork(importedNetworkPtr, modelFilenameStream.str(), config, &_resp)) << _resp.msg; @@ -197,10 +192,10 @@ TEST_F(myriadConfigsWithBlobImportTests_smoke, TryingToSetRuntimeOptionDoesNotPr std::map config = { {CONFIG_KEY(EXCLUSIVE_ASYNC_REQUESTS), CONFIG_VALUE(YES)}, {CONFIG_KEY(LOG_LEVEL), CONFIG_VALUE(LOG_INFO)}, {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)}, - {VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME), CONFIG_VALUE(YES)} }; + {InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, CONFIG_VALUE(YES)} }; if (vpu::tests::deviceForceReset()) { - config.insert({VPU_MYRIAD_CONFIG_KEY(FORCE_RESET), CONFIG_VALUE(NO)}); - config.insert({VPU_CONFIG_KEY(PLATFORM), VPU_CONFIG_VALUE(2480)}); + config.insert({InferenceEngine::MYRIAD_ENABLE_FORCE_RESET, CONFIG_VALUE(NO)}); + config.insert({VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2480)}); } InferenceEngine::IExecutableNetwork::Ptr importedNetworkPtr; @@ -416,4 +411,4 @@ static const std::vector outputPrecisions = {Inferen INSTANTIATE_TEST_CASE_P(accuracy, myriadBlobExportAccuracyDifferentPrecisionOfInAndOutTests_smoke, - ::testing::Combine(::testing::ValuesIn(inputPrecisions), ::testing::ValuesIn(outputPrecisions))); \ No newline at end of file + ::testing::Combine(::testing::ValuesIn(inputPrecisions), ::testing::ValuesIn(outputPrecisions))); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_clamp_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_clamp_test.hpp index 4b28d9fc13a..a201e14581b 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_clamp_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_clamp_test.hpp @@ -21,7 +21,7 @@ struct clamp_test_params { typedef myriadLayerTestBaseWithParam> myriadLayersTestsClampParams_smoke; TEST_P(myriadLayersTestsClampParams_smoke, TestsClamp) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); auto param = GetParam(); SizeVector tensor = std::get<0>(param); clamp_test_params p = std::get<1>(param); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_conv_nd_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_conv_nd_test.hpp index 42bedcd42c5..f12c1eabb63 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_conv_nd_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_conv_nd_test.hpp @@ -51,8 +51,8 @@ class ConvNDTest: public myriadLayerTestBaseWithParam protected: void testConvND() { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); - _config[VPU_CONFIG_KEY(HW_INJECT_STAGES)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_HW_INJECT_STAGES] = CONFIG_VALUE(NO); // // Get test parameters diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convert_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convert_test.hpp index 571e984621d..239b9330fa9 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convert_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convert_test.hpp @@ -36,9 +36,9 @@ TEST_P(myriadLayersTestsIOConvert_smoke, TestsIOConvert) { if(!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP()<<"Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; - _config[VPU_CONFIG_KEY(DISABLE_CONVERT_STAGES)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DISABLE_CONVERT_STAGES] = CONFIG_VALUE(YES); SetInputTensors({dims}); SetOutputTensors({dims}); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution1x1.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution1x1.hpp index 4ddafc8a679..505f820a70d 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution1x1.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution1x1.hpp @@ -139,8 +139,8 @@ TEST_P(myriadConvolution1x1LayerTests_smoke, Convolution1x1) { if(!customConfig.custom_config.empty() && !CheckMyriadX()) { GTEST_SKIP()<<"Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION)] = HWConfigValue; - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig.custom_config; + _config[InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION] = HWConfigValue; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig.custom_config; int IB = customConfig.src_dims[0]; int IC = customConfig.src_dims[1]; @@ -186,7 +186,9 @@ TEST_P(myriadConvolution1x1LayerTests_smoke, Convolution1x1) { _outputsInfo["conv1x1"]->setLayout(layout); ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, - {{VPU_CONFIG_KEY(CUSTOM_LAYERS), customConfig.custom_config}, {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), HWConfigValue}}, &_resp)); + {{InferenceEngine::MYRIAD_CUSTOM_LAYERS, customConfig.custom_config}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, HWConfigValue}}, + &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(_exeNetwork, nullptr) << _resp.msg; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution3x3.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution3x3.hpp index bf06022988c..2df83a7499c 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution3x3.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution3x3.hpp @@ -151,8 +151,8 @@ TEST_P(myriadConvolution3x3LayerTests_smoke, Convolution3x3) { if(!customConfig.custom_config.empty() && !CheckMyriadX()) { GTEST_SKIP()<<"Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION)] = HWConfigValue; - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig.custom_config; + _config[InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION] = HWConfigValue; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig.custom_config; int IB = customConfig.src_dims[0]; int IC = customConfig.src_dims[1]; @@ -201,7 +201,9 @@ TEST_P(myriadConvolution3x3LayerTests_smoke, Convolution3x3) { _outputsInfo["conv3x3"]->setLayout(NCHW); ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, - {{VPU_CONFIG_KEY(CUSTOM_LAYERS), customConfig.custom_config}, {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), HWConfigValue}}, &_resp)); + {{InferenceEngine::MYRIAD_CUSTOM_LAYERS, customConfig.custom_config}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, HWConfigValue}}, + &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(_exeNetwork, nullptr) << _resp.msg; @@ -281,4 +283,4 @@ static std::vector s_DimsConfig = { {{1, 256, 30, 30}, {1, 256, 14, 14}, 2, getIELibraryPath() + "/vpu_custom_kernels/customLayerBindings.xml"}, {{1, 256, 16, 16}, {1, 384, 7, 7}, 2, getIELibraryPath() + "/vpu_custom_kernels/customLayerBindings.xml"}, #endif -}; \ No newline at end of file +}; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution_test.hpp index 9beac09790d..31c18024e32 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution_test.hpp @@ -239,9 +239,9 @@ TEST_P(myriadLayers_IR3_ConvTests_smoke, Conv) { group = std::get<6>(p); get_dims(input_tensor, IW, IH, IC, I_N); if (I_N > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); size_t out_w = (IW + pads_begin.x + pads_end.x - kernel.x + stride.x) / stride.x; size_t out_h = (IH + pads_begin.y + pads_end.y - kernel.y + stride.y) / stride.y; gen_dims(output_tensor, input_tensor.size(), out_w, out_h, out_channels, I_N); @@ -354,9 +354,9 @@ TEST_P(myriadLayers_BatchTest_ConvTests_smoke, Conv) { group = std::get<6>(p); get_dims(input_tensor, IW, IH, IC, I_N); if (I_N > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); size_t out_w = (IW + pads_begin.x + pads_end.x - kernel.x + stride.x) / stride.x; size_t out_h = (IH + pads_begin.y + pads_end.y - kernel.y + stride.y) / stride.y; gen_dims(output_tensor, input_tensor.size(), out_w, out_h, out_channels, I_N); @@ -605,9 +605,9 @@ TEST_P(myriadLayers_BatchTest2_ConvTests_smoke, Conv) { group = std::get<6>(p); get_dims(input_tensor, IW, IH, IC, I_N); if (I_N > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); size_t out_w = (IW + pads_begin.x + pads_end.x - kernel.x + stride.x) / stride.x; size_t out_h = (IH + pads_begin.y + pads_end.y - kernel.y + stride.y) / stride.y; gen_dims(output_tensor, input_tensor.size(), out_w, out_h, out_channels, I_N); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_copy_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_copy_test.hpp index c93488d525f..2e78063daab 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_copy_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_copy_test.hpp @@ -37,7 +37,7 @@ TEST_P(myriadLayerCopy_smoke, Copy) { SetInputTensors(inputTensors); SetOutputTensors(outputTensors); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); ASSERT_NO_FATAL_FAILURE(makeSingleLayerNetwork(LayerInitParams("Copy"))); SetFirstInputToRange(1.0f, 100.0f); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_custom_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_custom_test.hpp index 2e838f71a26..a446a710f55 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_custom_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_custom_test.hpp @@ -647,7 +647,7 @@ TEST_P(myriadLayersTestsShuffleChannel_smoke, ShuffleChannel) { if(!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP()<<"Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; SetInputTensor(dims); SetOutputTensor(dims); @@ -683,7 +683,7 @@ TEST_P(myriadLayersTestsFakeQuantize_smoke, FakeQuantize) { if (!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP() << "Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; srand(42); @@ -863,7 +863,7 @@ TEST_P(myriadLayersTestsQuantizeBinarize_smoke, Quantize_Binarization) { if(!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP()<<"Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; int IB = dims.n; int IC = dims.c; @@ -932,7 +932,7 @@ TEST_P(myriadLayersTestsQuantizeBinarize_smoke, Quantize_Binarization) { _outputsInfo["Quantize"]->setLayout(NCHW); ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, - {{VPU_CONFIG_KEY(CUSTOM_LAYERS), customConfig }}, &_resp)); + {{InferenceEngine::MYRIAD_CUSTOM_LAYERS, customConfig }}, &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(_exeNetwork, nullptr) << _resp.msg; @@ -1055,7 +1055,7 @@ TEST_P(myriadLayersTestsBinaryConvolution_smoke, BinaryConvolution) { if(!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP()<<"Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; SetInputTensor(dims); auto dimsOutput = dims; @@ -1127,7 +1127,7 @@ TEST_P(myriadLayersTestsExperimentalDetectronPriorGridGenerator_smoke, if(!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP() << "Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; IN_OUT_desc inputTensors = {{1, 1, 3, 4}, image_dims, {1, 3, 480, 480}}; IN_OUT_desc outputTensors = {{1, 1, @@ -1192,7 +1192,7 @@ TEST_P(myriadLayersTestsCorrelate_smoke, Correlate) { if(!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP() << "Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; const int paddedbottomwidth = dims.w + 2 * pad_size; const int paddedbottomheight = dims.h + 2 * pad_size; @@ -1275,7 +1275,7 @@ TEST_P(myriadLayersTestsSpatialTransform_smoke, SpatialTransform) { if(!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP() << "Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; SetInputTensors({dims.asVector(), {1, 1, 2, 3}}); SetOutputTensor(dims); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_deconvolution_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_deconvolution_test.hpp index 7c3af16da77..526b7df15f2 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_deconvolution_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_deconvolution_test.hpp @@ -60,9 +60,9 @@ TEST_P(myriadLayerDeconvolution_smoke, Deconvolution) { } if (input_dims.n > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); size_t out_w = stride.x * (input_dims.w - 1) + kernel.x - 2 * pad.x; size_t out_h = stride.y * (input_dims.h - 1) + kernel.y - 2 * pad.y; @@ -130,9 +130,9 @@ TEST_P(myriadLayerDeconvolution_asymm_pad, Deconvolution) { } if (input_dims.n > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); size_t out_w = stride.x * (input_dims.w - 1) + kernel.x - (pad.x + pad_end.x); size_t out_h = stride.y * (input_dims.h - 1) + kernel.y - (pad.y + pad_end.y); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.cpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.cpp index 62031c6f8dc..ce54757ea24 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.cpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.cpp @@ -255,7 +255,7 @@ TEST_F(myriadLayersTestsEltwiseBase, EltwiseWithSameInputs) { InferenceEngine::Blob::Ptr inputBlob; InferenceEngine::IExecutableNetwork::Ptr exeNetwork; - std::map networkConfig = {{VPU_CONFIG_KEY(PERF_REPORT_MODE), VPU_CONFIG_VALUE(PER_STAGE)}}; + std::map networkConfig = {{InferenceEngine::MYRIAD_PERF_REPORT_MODE, InferenceEngine::MYRIAD_PER_STAGE}}; ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(exeNetwork, network, networkConfig, &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(exeNetwork, nullptr) << _resp.msg; @@ -491,9 +491,10 @@ TEST_F(myriadLayersTests_nightly, MergeEltwiseWithReLU) { outputInfo->setPrecision(Precision::FP16); StatusCode st; - ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, { {VPU_CONFIG_KEY(PERF_REPORT_MODE), VPU_CONFIG_VALUE(PER_STAGE)}, - {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)}, - {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(NO)} }, + ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, + { {InferenceEngine::MYRIAD_PERF_REPORT_MODE, InferenceEngine::MYRIAD_PER_STAGE}, + {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(NO)} }, &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(_exeNetwork, nullptr) << _resp.msg; @@ -722,10 +723,11 @@ TEST_F(myriadLayersTests_nightly, MergeEltwiseWithLeakyReLU) { outputInfo->setPrecision(Precision::FP16); StatusCode st; - ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, { {VPU_CONFIG_KEY(PERF_REPORT_MODE), VPU_CONFIG_VALUE(PER_STAGE)}, - {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)}, - {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(NO)} }, - &_resp)); + ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, + { {InferenceEngine::MYRIAD_PERF_REPORT_MODE, InferenceEngine::MYRIAD_PER_STAGE}, + {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(NO)} }, + &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(_exeNetwork, nullptr) << _resp.msg; @@ -953,10 +955,12 @@ TEST_F(myriadLayersTests_nightly, MergeEltwiseWithClamp) { outputInfo->setPrecision(Precision::FP16); StatusCode st; - ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network,{ {VPU_CONFIG_KEY(PERF_REPORT_MODE), VPU_CONFIG_VALUE(PER_STAGE)}, - {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)}, - {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(NO)} }, - &_resp)); + ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork( + _exeNetwork, network, + { {InferenceEngine::MYRIAD_PERF_REPORT_MODE, InferenceEngine::MYRIAD_PER_STAGE}, + {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(NO)} }, + &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(_exeNetwork, nullptr) << _resp.msg; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.hpp index c15e165adc1..94b33390790 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.hpp @@ -356,9 +356,9 @@ protected: SetInputTensors(inpt); SetOutputTensors({dims}); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); if (!CheckMyriadX()) { - _config[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(YES); } ASSERT_NO_FATAL_FAILURE(makeSingleLayerNetwork(LayerInitParams("Eltwise").params(_params))); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_elu_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_elu_test.hpp index 83b7e4eb998..b0a84210da5 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_elu_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_elu_test.hpp @@ -32,7 +32,7 @@ void gen_ref_elu(const InferenceEngine::Blob::Ptr src, typedef myriadLayerTestBaseWithParam> myriadLayersTestsELUParams_smoke; TEST_P(myriadLayersTestsELUParams_smoke, TestsELU) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); auto param = GetParam(); SizeVector tensor = std::get<0>(param); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_erf_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_erf_test.hpp index 07de3354c60..9d4c32641e9 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_erf_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_erf_test.hpp @@ -33,7 +33,7 @@ public: TEST_P(myriadLayersTestsErf_smoke, TestsErf) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); auto p = ::testing::WithParamInterface::GetParam(); SetInputTensors({p}); SetOutputTensors({p}); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_detectionoutput_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_detectionoutput_test.hpp index 5d168f6ff97..f104dd06b77 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_detectionoutput_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_detectionoutput_test.hpp @@ -154,7 +154,7 @@ class ExpDetectionOutputTest: public myriadLayerTestBaseWithParam(testParams); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_generateproposals_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_generateproposals_test.hpp index 433caca1c71..e98fe028ed7 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_generateproposals_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_generateproposals_test.hpp @@ -147,7 +147,7 @@ TEST_P(myriadLayersTestsExpGenerateProposals_smoke, ExpGenerateProposals) { const auto numProposals = scoresDims.c * scoresDims.h * scoresDims.w; - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); IN_OUT_desc inputTensors, outputTensors; inputTensors.push_back({3}); // im info diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_priorgridgenerator_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_priorgridgenerator_test.hpp index 04f14e6104d..7cf3b9470c7 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_priorgridgenerator_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_priorgridgenerator_test.hpp @@ -76,7 +76,7 @@ class myriadLayersTestsExpPriorGridGen : public myriadLayerTestBaseWithParam(GetParam()); TopKROIsParam opParams = std::get<1>(GetParam()); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); IN_OUT_desc inputTensors, outputTensors; inputTensors.push_back({static_cast(inputRoisNum), NUM_COORDS}); // input rois diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_fully_connected_tests.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_fully_connected_tests.hpp index b5c9ef536f0..8ff670b418a 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_fully_connected_tests.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_fully_connected_tests.hpp @@ -98,9 +98,9 @@ TEST_P(myriadLayersTestsFullyConnectedBatch_smoke, TestsFullyConnected) get_dims(input_tensor, IW, IH, IC, I_N); InferenceEngine::SizeVector output_tensor = {(size_t)I_N, (size_t)out_size}; if (I_N > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); size_t sz_weights = IC * IH * IW * out_size; size_t sz_bias = 0; @@ -136,9 +136,9 @@ TEST_P(myriadLayersTestsFullyConnectedPVA_smoke, TestsFullyConnected) get_dims(input_tensor, IW, IH, IC, I_N); InferenceEngine::SizeVector output_tensor = {(size_t)I_N, (size_t)out_size}; if (I_N > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); size_t sz_weights = IC * IH * IW * out_size; size_t sz_bias = 0; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gather_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gather_test.hpp index 512fda7585c..149c29616f8 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gather_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gather_test.hpp @@ -31,7 +31,7 @@ protected: void testGather() { SKIP_IF_CURRENT_TEST_IS_DISABLED(); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); // // Parse and check test parameters diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gemm_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gemm_test.hpp index 65380edc079..2325fe95da7 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gemm_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gemm_test.hpp @@ -166,9 +166,9 @@ TEST_P(myriadLayerGEMM_smoke, GEMM) { }; if (MB1_D > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); ASSERT_NO_FATAL_FAILURE(makeSingleLayerNetwork(LayerInitParams("GEMM").params(params), NetworkInitParams().layoutPreference(layoutPreference))); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_grn_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_grn_test.hpp index 5a2cb7eba17..d35a8aba969 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_grn_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_grn_test.hpp @@ -56,7 +56,7 @@ TEST_P(myriadLayersTestsGRN_smoke, GRN) { if (!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP() << "Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; SetInputTensors({dims}); SetOutputTensors({dims}); @@ -86,4 +86,4 @@ static std::vector s_CustomConfig = { static std::vector s_GRNInputs = { {1, 3, 16, 224}, {1, 24, 128, 224}, -}; \ No newline at end of file +}; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.cpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.cpp index 825b5773e01..69263ba7a3f 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.cpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.cpp @@ -67,7 +67,7 @@ TEST_F(myriadLayersTests_nightly, MVN_CHW_Input) _outputsInfo["mvn"]->setPrecision(Precision::FP16); ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, - {{VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES)}}, &_resp)); + {{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES)}}, &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(_exeNetwork, nullptr) << _resp.msg; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.hpp index ae7741b6ffd..a1b1310e4a2 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.hpp @@ -150,7 +150,7 @@ TEST_P(myriadLayersTestsMVN_smoke, MVN) if(!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP()<<"Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; SetInputTensor(dims); SetOutputTensor(dims); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_nonzero_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_nonzero_test.hpp index c2571170546..a15caa91858 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_nonzero_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_nonzero_test.hpp @@ -72,7 +72,7 @@ protected: }; void myriadLayerTestNonZero_smoke::testNonZero(vpu::LayoutPreference preference, Precision precision) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); const auto& inputDims = GetParam(); const size_t numDims = inputDims.size(); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_oneHot_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_oneHot_test.hpp index 58f4fc6193a..44f4d703bb1 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_oneHot_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_oneHot_test.hpp @@ -54,7 +54,7 @@ void ref_oneHot(const InferenceEngine::Blob::Ptr src, typedef myriadLayerTestBaseWithParam myriadLayerTestOneHot_smoke; TEST_P(myriadLayerTestOneHot_smoke, OneHot) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); OneHotParams testParams = GetParam(); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_nd_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_nd_test.hpp index 736716d2b1f..93a86e1b135 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_nd_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_nd_test.hpp @@ -91,7 +91,7 @@ TEST_P(myriadLayersPermuteNDTests_smoke, Permute) { const std::map layerParams{{"order", order}}; - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); switch (precision) { @@ -185,4 +185,4 @@ static const std::vector s_permuteTensors_5D = { static const std::vector s_permutePrecisions = { InferenceEngine::Precision::I32, InferenceEngine::Precision::FP16, -}; \ No newline at end of file +}; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_test.hpp index cbc8bc8b5af..47d41201461 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_test.hpp @@ -70,9 +70,9 @@ TEST_P(myriadLayersPermuteTests_smoke, Permute) { auto order = std::get<1>(p); get_dims(input_tensor, IW, IH, IC, I_N); if (I_N > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); if (input_tensor.size()) { gen_dims(output_tensor, input_tensor.size(), input_tensor[order[3]], input_tensor[order[2]], diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pool_nd_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pool_nd_test.hpp index 232953e223b..d90c7bcccf5 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pool_nd_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pool_nd_test.hpp @@ -190,7 +190,7 @@ protected: // Initialize network // - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); std::string model = createModel(inputShape, outputShape, diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pooling_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pooling_test.hpp index c1923c65257..89822c2a748 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pooling_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pooling_test.hpp @@ -111,9 +111,9 @@ TEST_P(myriadLayers_IR3_PoolingTests_smoke, Pooling) { get_dims(input_tensor, IW, IH, IC, I_N); if (I_N > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); int32_t OW = 1; int32_t OH = 1; int32_t OC = 1; @@ -191,9 +191,9 @@ TEST_P(myriadLayers_IR3_BatchPoolingTests_smoke, Pooling) { get_dims(input_tensor, IW, IH, IC, I_N); if (I_N > 1) - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); else - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(YES); int32_t OW = 1; int32_t OH = 1; int32_t OC = 1; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_power_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_power_test.hpp index c2086c75727..082a859f904 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_power_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_power_test.hpp @@ -42,7 +42,7 @@ static void gen_ref_power(const InferenceEngine::Blob::Ptr src, typedef myriadLayerTestBaseWithParam> myriadLayersTestsPowerParams_smoke; TEST_P(myriadLayersTestsPowerParams_smoke, TestsPower) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); auto param = GetParam(); SizeVector tensor = std::get<0>(param); pwr_test_params p = std::get<1>(param); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_prelu_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_prelu_test.hpp index 78394dd209b..12dd20562b0 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_prelu_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_prelu_test.hpp @@ -15,7 +15,7 @@ PRETTY_PARAM(ChannelSharedPrelu, int); typedef myriadLayerTestBaseWithParam> myriadLayerPReLU_smoke; TEST_P(myriadLayerPReLU_smoke, PReLU) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); SizeVector dims = get<0>(GetParam()); int channel_shared = get<1>(GetParam()); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reduce_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reduce_test.hpp index 4de534921b6..451ef232958 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reduce_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reduce_test.hpp @@ -386,7 +386,7 @@ protected: void testReduce() { DISABLE_IF(!CheckMyriadX()); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); const auto params = GetParam(); const auto inputPair = std::get<0>(params); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_region_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_region_test.hpp index 71090b00ea6..55cd947c3bb 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_region_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_region_test.hpp @@ -34,7 +34,7 @@ TEST_P(myriadLayersTestsRegionYolo_smoke, RegionYolo) { GTEST_SKIP() << "Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; const auto mask = [&] { std::string mask; @@ -82,4 +82,4 @@ std::vector s_CustomConfig = { #ifdef VPU_HAS_CUSTOM_KERNELS getIELibraryPath() + "/vpu_custom_kernels/customLayerBindings.xml" #endif -}; \ No newline at end of file +}; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_relu_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_relu_test.hpp index 4337eda7440..c603c23f890 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_relu_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_relu_test.hpp @@ -28,8 +28,9 @@ public: _outputsInfo = network.getOutputsInfo(); _outputsInfo["relu"]->setPrecision(Precision::FP16); - ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, { {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)}, - {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(NO)} }, + ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, + { {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(NO)} }, &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(_exeNetwork, nullptr) << _resp.msg; @@ -68,7 +69,7 @@ static std::vector s_reluLayerParams = { typedef myriadLayerTestBaseWithParam> myriadLayerReLU_smoke; TEST_P(myriadLayerReLU_smoke, ReLU) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); auto input_dims = std::get<0>(GetParam()); auto extraLayerParams = std::get<1>(GetParam()); IN_OUT_desc input_tensor; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reorg_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reorg_test.hpp index 1fa387b6420..372d6155b34 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reorg_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reorg_test.hpp @@ -74,7 +74,7 @@ TEST_P(myriadLayersTestsReorg_smoke, TestsReorg) { if(!customConfig.empty() && !CheckMyriadX()) { GTEST_SKIP() << "Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; const auto dimsOutput = SizeVector{dimsInput[0], dimsInput[1] * (stride * stride), @@ -110,4 +110,4 @@ static std::vector s_ReorgInputs = { {1, 64, 26, 26}, {1, 192, 6 * 26, 6 * 26}, {1, 4, 6, 6} -}; \ No newline at end of file +}; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_resample_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_resample_test.hpp index ada3a740900..a160565d12b 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_resample_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_resample_test.hpp @@ -114,7 +114,7 @@ TEST_P(myriadResampleLayerTests_smoke, Resample) { GTEST_SKIP() << "Custom layers for MYRIAD2 not supported"; } - _config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = customConfig; + _config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = customConfig; const auto outputDims = SizeVector{inputDims[0], inputDims[1], diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.cpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.cpp index a5abd89aeba..3fb187e1d10 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.cpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.cpp @@ -13,11 +13,11 @@ TEST_F(myriadEliminateReshapeTests_smoke, SplitConvConcat) { ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, _cnnNetwork, { { - VPU_CONFIG_KEY(PERF_REPORT_MODE), - VPU_CONFIG_VALUE(PER_STAGE) + InferenceEngine::MYRIAD_PERF_REPORT_MODE, + InferenceEngine::MYRIAD_PER_STAGE }, { - VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), + InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(NO) }, { @@ -206,9 +206,10 @@ TEST_F(myriadLayersTests_nightly, ReshapeAfterConcat_Eliminate) { _outputsInfo = network.getOutputsInfo(); _outputsInfo["reshape_copy"]->setPrecision(Precision::FP16); - ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, { {VPU_CONFIG_KEY(PERF_REPORT_MODE), VPU_CONFIG_VALUE(PER_STAGE)}, - {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(NO)}, - {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)} }, &_resp)); + ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, + { {InferenceEngine::MYRIAD_PERF_REPORT_MODE, InferenceEngine::MYRIAD_PER_STAGE}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(NO)}, + {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES)} }, &_resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; ASSERT_NE(_exeNetwork, nullptr) << _resp.msg; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.hpp index 942c6551e66..5166f5029bd 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.hpp @@ -32,7 +32,7 @@ TEST_P(myriadLayerReshape_smoke, Reshape) { .out({output_tensor}), ref_reshape_wrap); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); ASSERT_TRUE(generateNetAndInfer(NetworkInitParams().useHWOpt(CheckMyriadX()).layoutPreference(vpu::LayoutPreference::ChannelMinor))); } @@ -223,9 +223,9 @@ TEST_P(myriadLayersTestsReshapeBeforeFC_smoke, OptimizeReshapeIfItIsPlacedBefore InferenceEngine::IExecutableNetwork::Ptr exeNetwork; ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(exeNetwork, network, - { {VPU_CONFIG_KEY(PERF_REPORT_MODE), VPU_CONFIG_VALUE(PER_STAGE)}, - {VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), HWConfigValue}, - {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES) }}, &resp)); + { {InferenceEngine::MYRIAD_PERF_REPORT_MODE, InferenceEngine::MYRIAD_PER_STAGE}, + {InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, HWConfigValue}, + {CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES) }}, &resp)); ASSERT_EQ(StatusCode::OK, st) << _resp.msg; InferenceEngine::IInferRequest::Ptr inferRequest; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reverse_sequence_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reverse_sequence_test.hpp index 829f3e9821d..6ef6ba63a19 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reverse_sequence_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reverse_sequence_test.hpp @@ -105,7 +105,7 @@ static void ref_reverse_sequence( } TEST_P(myriadLayerReverseSequence_smoke, ReverseSequence) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); reverse_sequence_test_params input_dims = std::get<0>(GetParam()); _irVersion = std::get<1>(GetParam()); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_align_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_align_test.hpp index f2c3021ae52..fa1ec5071f4 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_align_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_align_test.hpp @@ -162,7 +162,7 @@ static std::string getModel(const int batches, const int channels, const int hei } TEST_P(myriadLayersTestsROIAlign_smoke, ROIAlign) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); const tensor_test_params dims_layer_in = std::get<0>(GetParam()); const roi_align_param test_params = std::get<1>(GetParam()); @@ -255,4 +255,4 @@ static std::vector s_ROIAlignNumROIs = { static std::vector s_ROIAlignMode = { std::string("avg"), std::string("max") -}; \ No newline at end of file +}; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_feature_extractor_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_feature_extractor_test.hpp index 2d3933e3ba4..039afc28410 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_feature_extractor_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_feature_extractor_test.hpp @@ -63,7 +63,7 @@ TEST_P(myriadLayersTestsROIFeatureExtractor_smoke, ROIFeatureExtractor) { bool use_output_rois = true; const int levels_num = 4; - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); IN_OUT_desc input_tensors, output_tensors; input_tensors.push_back({num_rois, NUM_ELEM_ROIS}); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scale_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scale_test.hpp index 956e025080b..812afc02fea 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scale_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scale_test.hpp @@ -103,7 +103,7 @@ class myriadLayersTestsScale_smoke: public myriadLayersTests_nightly, TEST_P(myriadLayersTestsScale_smoke, TestsScale) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); SizeVector p = std::get<0>(::testing::WithParamInterface::GetParam()); bool biasAdd = std::get<1>(::testing::WithParamInterface::GetParam()); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_elements_update_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_elements_update_test.hpp index 11819617715..a8ba6d5b078 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_elements_update_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_elements_update_test.hpp @@ -48,7 +48,7 @@ protected: void testScatterElementsUpdate() { SKIP_IF_CURRENT_TEST_IS_DISABLED(); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); // // Parse test parameters diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_update_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_update_test.hpp index a9f497d3a6f..111e9a8b61b 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_update_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_update_test.hpp @@ -49,7 +49,7 @@ class myriadLayersScatterUpdateTest_smoke: protected: void testScatterUpdate() { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); // // Get and verify test parameters, and deduce other parameters diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_select_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_select_test.hpp index ac7d8d84e88..1bd176749c1 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_select_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_select_test.hpp @@ -104,7 +104,7 @@ protected: SetInputTensors(inpt); SetOutputTensors({dims}); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); ASSERT_NO_FATAL_FAILURE(makeSingleLayerNetwork(LayerInitParams("Select").params(_params))); ASSERT_TRUE(Infer()); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_sigmoid_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_sigmoid_test.hpp index c4ec91e16b1..5bfeffb020b 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_sigmoid_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_sigmoid_test.hpp @@ -20,7 +20,7 @@ public: TEST_P(myriadLayersTestsSigmoid_smoke, TestsSigmoid) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); SizeVector p = GetParam(); SetInputTensors({p}); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_slice_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_slice_test.hpp index 1a8f2094a1a..2e5c53ffa80 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_slice_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_slice_test.hpp @@ -19,7 +19,7 @@ PRETTY_PARAM(SliceTestParams, SliceParams); typedef myriadLayerTestBaseWithParam myriadLayersTestsSlice_smoke; TEST_P(myriadLayersTestsSlice_smoke, Slice) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); const SliceParams testParams = GetParam(); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_softmax_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_softmax_test.hpp index 93d8eb76b66..38fdb639f6b 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_softmax_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_softmax_test.hpp @@ -33,7 +33,7 @@ protected: TEST_P(myriadLayersTestsSoftMax_smoke, TestsSoftMax) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); SetInputTensors({_testingInput.sizes}); SetOutputTensors({_testingInput.sizes}); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_split_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_split_test.hpp index a4cbe23b30c..c79983df210 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_split_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_split_test.hpp @@ -19,7 +19,7 @@ PRETTY_PARAM(SplitTestParams, SplitParams); typedef myriadLayerTestBaseWithParam myriadLayersTestsSplit_smoke; TEST_P(myriadLayersTestsSplit_smoke, Split) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); const SplitParams testParams = GetParam(); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_strided_slice_test.h b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_strided_slice_test.h index 7a1f35f6469..da7cbdf0c69 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_strided_slice_test.h +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_strided_slice_test.h @@ -242,10 +242,10 @@ TEST_P(myriadLayersTestsStridedSlice_smoke, TestsStridedSlice) { StatusCode st = GENERAL_ERROR; std::map config = { - { VPU_CONFIG_KEY(DETECT_NETWORK_BATCH), CONFIG_VALUE(NO) } + { InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH, CONFIG_VALUE(NO) } }; if (!CheckMyriadX()) { - config.insert({ VPU_CONFIG_KEY(DISABLE_REORDER), CONFIG_VALUE(YES) }); + config.insert({ InferenceEngine::MYRIAD_DISABLE_REORDER, CONFIG_VALUE(YES) }); } ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork( diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tanh_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tanh_test.hpp index a72e3d022c5..7fd4916029a 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tanh_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tanh_test.hpp @@ -16,7 +16,7 @@ class myriadLayersTestsTanh_smoke: public myriadLayersTests_nightly, TEST_P(myriadLayersTestsTanh_smoke, TestsTanh) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); auto p = ::testing::WithParamInterface::GetParam(); SetInputTensors({p}); SetOutputTensors({p}); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tile_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tile_test.hpp index 8424212fa24..d2452b6edc0 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tile_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tile_test.hpp @@ -109,7 +109,7 @@ void ref_tile(const InferenceEngine::Blob::Ptr src, typedef myriadLayerTestBaseWithParam> myriadLayerTestTile_smoke; TEST_P(myriadLayerTestTile_smoke, Tile) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); tile_test::nd_tensor_test_params input_dims = get<0>(GetParam()); int tiles = get<1>(GetParam()); diff --git a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_topk_test.hpp b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_topk_test.hpp index 6b589068ed8..63f363ceff5 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_topk_test.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_topk_test.hpp @@ -33,7 +33,7 @@ class TopKTest: public myriadLayerTestBaseWithParam { protected: void testTopK(const IRVersion irVersion, const bool outputValues, const bool outputIndices) { - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); _config[CONFIG_KEY(PERF_COUNT)] = CONFIG_VALUE(YES); _irVersion = irVersion; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_conv_tests.hpp b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_conv_tests.hpp index 9cd50e70e40..60efef04a2d 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_conv_tests.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_conv_tests.hpp @@ -49,7 +49,7 @@ public: numWeights = kernel.x * kernel.y * (in_dims.c / group) * out_dims.c; numBiases = out_dims.c; - _config[VPU_CONFIG_KEY(HW_DILATION)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_HW_DILATION] = CONFIG_VALUE(YES); } void AddInitialCopyLayer() { diff --git a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_extra_tests.hpp b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_extra_tests.hpp index adb6ed2c88d..9a5460b4c31 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_extra_tests.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_extra_tests.hpp @@ -668,11 +668,11 @@ TEST_F(MyriadX_HW_Tests_nightly, With_3_FC_Layers) { ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, network, { { - VPU_CONFIG_KEY(PERF_REPORT_MODE), - VPU_CONFIG_VALUE(PER_STAGE) + InferenceEngine::MYRIAD_PERF_REPORT_MODE, + InferenceEngine::MYRIAD_PER_STAGE }, { - VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), + InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES) }, }, diff --git a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_fc_tests.hpp b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_fc_tests.hpp index 1a32e18a06b..fa92f790ea9 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_fc_tests.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_fc_tests.hpp @@ -28,7 +28,7 @@ public: in_tensor.push_back({p.in.n, p.in.c, p.in.h, p.in.w}); out_tensor.push_back({p.in.n, p.out_c}); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); } void AddFCLayer() { diff --git a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_network_tests.hpp b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_network_tests.hpp index 98374d092d8..cd31caa4ad8 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_network_tests.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_network_tests.hpp @@ -73,9 +73,9 @@ public: const int NUM_REQUESTS = 4; std::map config = { - { VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), CONFIG_VALUE(YES) }, + { InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, CONFIG_VALUE(YES) }, { CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES) }, - { VPU_CONFIG_KEY(PERF_REPORT_MODE), VPU_CONFIG_VALUE(PER_STAGE) } + { InferenceEngine::MYRIAD_PERF_REPORT_MODE, InferenceEngine::MYRIAD_PER_STAGE } }; StatusCode st; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_pool_tests.hpp b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_pool_tests.hpp index 695cd8e3c7b..d4e787d7405 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_pool_tests.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_pool_tests.hpp @@ -37,7 +37,7 @@ public: in_tensor.push_back({in_dims.n, in_dims.c, in_dims.h, in_dims.w}); out_tensor.push_back({out_dims.n, out_dims.c, out_dims.h, out_dims.w}); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); } void AddPoolingLayer(const std::string& poolMethod) { diff --git a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_tests_base.hpp b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_tests_base.hpp index 7ec8a7f442a..3d5b01e9352 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_tests_base.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_tests_base.hpp @@ -126,10 +126,10 @@ public: StatusCode st; std::map config = { - { VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION), runInfo.hwMode ? CONFIG_VALUE(YES) : CONFIG_VALUE(NO) }, + { InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, runInfo.hwMode ? CONFIG_VALUE(YES) : CONFIG_VALUE(NO) }, { CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES) }, - { VPU_CONFIG_KEY(PERF_REPORT_MODE), VPU_CONFIG_VALUE(PER_STAGE) }, + { InferenceEngine::MYRIAD_PERF_REPORT_MODE, InferenceEngine::MYRIAD_PER_STAGE }, { CONFIG_KEY(LOG_LEVEL), logLevel } }; diff --git a/inference-engine/tests_deprecated/functional/vpu/common/myriad_merge_permute_tests.hpp b/inference-engine/tests_deprecated/functional/vpu/common/myriad_merge_permute_tests.hpp index dd5757dfedf..c23e7c75f49 100644 --- a/inference-engine/tests_deprecated/functional/vpu/common/myriad_merge_permute_tests.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/common/myriad_merge_permute_tests.hpp @@ -26,8 +26,8 @@ public: ResetGeneratedNet(); ResetReferenceLayers(); - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH) ] = CONFIG_VALUE(NO); - _config[VPU_CONFIG_KEY(ENABLE_PERMUTE_MERGING)] = usePermuteMerging ? CONFIG_VALUE(YES) : CONFIG_VALUE(NO) ; + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH ] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_ENABLE_PERMUTE_MERGING] = usePermuteMerging ? CONFIG_VALUE(YES) : CONFIG_VALUE(NO) ; for (const auto& permutation_vector : permutation_vectors) { const auto num_dims = input_tensor_sizes.size(); diff --git a/inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_configs_tests.cpp b/inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_configs_tests.cpp index 67b783dc62f..32f02380cbc 100644 --- a/inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_configs_tests.cpp +++ b/inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_configs_tests.cpp @@ -84,45 +84,37 @@ TEST_P(myriadIncorrectModelsConfigsTests_nightly, LoadNetworkWithIncorrectConfig static const std::vector myriadCorrectPlatformConfigValues = { {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2450)}}, {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2480)}}, - {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), ""}}, - // Deprecated - {{VPU_CONFIG_KEY(PLATFORM), VPU_CONFIG_VALUE(2450)}}, - {{VPU_CONFIG_KEY(PLATFORM), VPU_CONFIG_VALUE(2480)}}, - {{VPU_CONFIG_KEY(PLATFORM), ""}} + {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), ""}} }; static const std::vector myriadIncorrectPlatformConfigValues = { {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "-1"}}, {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), " 0"}}, - {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "MyriadX"}}, - // Deprecated - {{VPU_CONFIG_KEY(PLATFORM), "-1"}}, - {{VPU_CONFIG_KEY(PLATFORM), " 0"}}, - {{VPU_CONFIG_KEY(PLATFORM), "MyriadX"}}, - // Deprecated key & value from current - {{VPU_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2450)}}, - {{VPU_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2480)}}, - // Current key & deprecated value - {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_CONFIG_VALUE(2450)}}, - {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_CONFIG_VALUE(2480)}}, + {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "MyriadX"}} }; static const std::vector myriadCorrectPackageTypeConfigValues = { // Please do not use other types of DDR in tests with a real device, because it may hang. + {{InferenceEngine::MYRIAD_DDR_TYPE, InferenceEngine::MYRIAD_DDR_AUTO}}, + + // Deprecated {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), VPU_MYRIAD_CONFIG_VALUE(DDR_AUTO)}} }; static const std::vector myriadIncorrectPackageTypeConfigValues = { + {{InferenceEngine::MYRIAD_DDR_TYPE, "-1"}}, + {{InferenceEngine::MYRIAD_DDR_TYPE, "-MICRON_1GB"}}, + // Deprecated {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), "-1"}}, {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), "-MICRON_1GB"}}, }; INSTANTIATE_TEST_CASE_P(MyriadConfigs, myriadCorrectModelsConfigsTests_nightly, - ::testing::ValuesIn(myriadCorrectPlatformConfigValues)); + ::testing::ValuesIn(myriadCorrectPlatformConfigValues)); INSTANTIATE_TEST_CASE_P(MyriadConfigs, myriadIncorrectModelsConfigsTests_nightly, - ::testing::ValuesIn(myriadIncorrectPlatformConfigValues)); + ::testing::ValuesIn(myriadIncorrectPlatformConfigValues)); INSTANTIATE_TEST_CASE_P(MyriadPackageConfigs, myriadCorrectModelsConfigsTests_nightly, ::testing::ValuesIn(myriadCorrectPackageTypeConfigValues)); diff --git a/inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_streams_configuration_tests.cpp b/inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_streams_configuration_tests.cpp index 0d0b7e14619..e6b13686767 100644 --- a/inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_streams_configuration_tests.cpp +++ b/inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_streams_configuration_tests.cpp @@ -11,7 +11,7 @@ namespace { class myriadCorrectStreamsConfiguration_nightly : public vpuLayersTests, public testing::WithParamInterface {}; TEST_P(myriadCorrectStreamsConfiguration_nightly, InfersWithConfiguredStreams) { - _config[VPU_MYRIAD_CONFIG_KEY(THROUGHPUT_STREAMS)] = std::to_string(GetParam()); + _config[InferenceEngine::MYRIAD_THROUGHPUT_STREAMS] = std::to_string(GetParam()); _irVersion = IRVersion::v10; auto fn_ptr = ngraph::builder::subgraph::makeSplitMultiConvConcat(); diff --git a/inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.cpp b/inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.cpp index 184e80b5414..5cbccf6cd1c 100644 --- a/inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.cpp +++ b/inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.cpp @@ -16,11 +16,11 @@ void myriadLayersTests_nightly::makeSingleLayerNetwork(const LayerParams& layerP const NetworkParams& networkParams, const WeightsBlob::Ptr& weights) { // Disable reorder in per-layer tests to make sure intended layout is used - _config[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(YES); + _config[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(YES); // White list of per-layer tests that allowed to reorder if (layerParams._layerType == "Flatten") { - _config[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(NO); } ASSERT_NO_FATAL_FAILURE( diff --git a/inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.hpp b/inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.hpp index a01238da4ec..4e62d468cc3 100644 --- a/inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.hpp +++ b/inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.hpp @@ -143,7 +143,7 @@ public: _output_tensor[2] = std::floor((_input_tensor[2] + 2. * _pad_val.y - _kernel_val.y) / _stride_val.y) + 1; _output_tensor[1] = _input_tensor[1]; _output_tensor[0] = _input_tensor[0]; - _config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO); + _config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO); ASSERT_EQ(_input_tensor.size(), 4); _testNet.addLayer(LayerInitParams("Pooling") .params(_params) diff --git a/inference-engine/tests_deprecated/functional/vpu/vpu_base/vpu_layers_tests.cpp b/inference-engine/tests_deprecated/functional/vpu/vpu_base/vpu_layers_tests.cpp index df7da691ee1..9a5be0b1b58 100644 --- a/inference-engine/tests_deprecated/functional/vpu/vpu_base/vpu_layers_tests.cpp +++ b/inference-engine/tests_deprecated/functional/vpu/vpu_base/vpu_layers_tests.cpp @@ -175,16 +175,16 @@ void vpuLayersTests::createInferRequest(const NetworkParams& params) { std::map config(_config); if (params._useHWOpt) { - config[VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION)] = CONFIG_VALUE(YES); + config[InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION] = CONFIG_VALUE(YES); } else { - config[VPU_CONFIG_KEY(HW_STAGES_OPTIMIZATION)] = CONFIG_VALUE(NO); + config[InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION] = CONFIG_VALUE(NO); } #if 0 config[CONFIG_KEY(LOG_LEVEL)] = CONFIG_VALUE(LOG_INFO); #endif config[CONFIG_KEY(PERF_COUNT)] = CONFIG_VALUE(YES); - config[VPU_CONFIG_KEY(PERF_REPORT_MODE)] = VPU_CONFIG_VALUE(PER_STAGE); - config[VPU_CONFIG_KEY(FORCE_DEPRECATED_CNN_CONVERSION)] = CONFIG_VALUE(NO); // Make VPU plugin be able to use NGraph network. + config[InferenceEngine::MYRIAD_PERF_REPORT_MODE] = InferenceEngine::MYRIAD_PER_STAGE; + config[InferenceEngine::MYRIAD_FORCE_DEPRECATED_CNN_CONVERSION] = CONFIG_VALUE(NO); // Make VPU plugin be able to use NGraph network. InferenceEngine::StatusCode st = InferenceEngine::StatusCode::GENERAL_ERROR; ASSERT_NO_THROW(st = _vpuPluginPtr->LoadNetwork(_exeNetwork, _cnnNetwork, config, &_resp)); @@ -253,7 +253,7 @@ bool vpuLayersTests::Infer() { const auto st = _inferRequest->Infer(&_resp); EXPECT_EQ(InferenceEngine::StatusCode::OK, st) << _resp.msg; // dumpPerformance(); - if (!_config[VPU_CONFIG_KEY(CUSTOM_LAYERS)].empty()) { + if (!_config[InferenceEngine::MYRIAD_CUSTOM_LAYERS].empty()) { EXPECT_TRUE(wasCustomLayerInferred()) << "CustomBindings.xml has been provided but Custom layer was not inferred"; } diff --git a/inference-engine/tests_deprecated/helpers/tests_vpu_common.hpp b/inference-engine/tests_deprecated/helpers/tests_vpu_common.hpp index fe392e607e8..0bdb05f6f7d 100644 --- a/inference-engine/tests_deprecated/helpers/tests_vpu_common.hpp +++ b/inference-engine/tests_deprecated/helpers/tests_vpu_common.hpp @@ -73,22 +73,7 @@ static bool hasAppropriateStick(const config_t &config) { suitsConfig = hasRequestedMyriad2 || hasRequestedMyriadX; } - bool suitsDeprecatedConfig; - // Deprecated api - IE_SUPPRESS_DEPRECATED_START - platform = config.find(VPU_CONFIG_KEY(PLATFORM)); - if (platform == config.end() || platform->second.empty()) { - suitsDeprecatedConfig = hasMyriad2() || hasMyriadX(); - } else { - bool hasRequestedMyriad2 = - platform->second == VPU_CONFIG_VALUE(2450) && hasMyriad2(); - bool hasRequestedMyriadX = - platform->second == VPU_CONFIG_VALUE(2480) && hasMyriadX(); - suitsDeprecatedConfig = hasRequestedMyriad2 || hasRequestedMyriadX; - } - IE_SUPPRESS_DEPRECATED_END - - return suitsConfig && suitsDeprecatedConfig; + return suitsConfig; } static bool hasHDDL_R() { diff --git a/inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_engine_tests.cpp b/inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_engine_tests.cpp index 8c7adbc2da5..32e8f241ee5 100644 --- a/inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_engine_tests.cpp +++ b/inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_engine_tests.cpp @@ -20,33 +20,25 @@ TEST_P(MyriadEngineSetIncorrectConfigTest, SetIncorrectConfig) { IE_SUPPRESS_DEPRECATED_START static const std::vector myriadCorrectPlatformConfigValues = { + // Deprecated {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2450)}}, {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2480)}}, - {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), ""}}, - // Deprecated - {{VPU_CONFIG_KEY(PLATFORM), VPU_CONFIG_VALUE(2450)}}, - {{VPU_CONFIG_KEY(PLATFORM), VPU_CONFIG_VALUE(2480)}}, - {{VPU_CONFIG_KEY(PLATFORM), ""}} + {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), ""}} }; static const std::vector myriadIncorrectPlatformConfigValues = { + // Deprecated {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "-1"}}, {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), " 0"}}, - {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "MyriadX"}}, - // Deprecated - {{VPU_CONFIG_KEY(PLATFORM), "-1"}}, - {{VPU_CONFIG_KEY(PLATFORM), " 0"}}, - {{VPU_CONFIG_KEY(PLATFORM), "MyriadX"}}, - // Deprecated key & value from current - {{VPU_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2450)}}, - {{VPU_CONFIG_KEY(PLATFORM), VPU_MYRIAD_CONFIG_VALUE(2480)}}, - // Current key & deprecated value - {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_CONFIG_VALUE(2450)}}, - {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), VPU_CONFIG_VALUE(2480)}}, - + {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), "MyriadX"}} }; static const std::vector myriadCorrectProtocolConfigValues = { + {{InferenceEngine::MYRIAD_PROTOCOL, InferenceEngine::MYRIAD_PCIE}}, + {{InferenceEngine::MYRIAD_PROTOCOL, InferenceEngine::MYRIAD_USB}}, + {{InferenceEngine::MYRIAD_PROTOCOL, ""}}, + + // Deprecated {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(PCIE)}}, {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), VPU_MYRIAD_CONFIG_VALUE(USB)}}, {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), ""}}, @@ -54,40 +46,57 @@ static const std::vector myriadCorrectProtocolConfigValues = { static const std::vector myriadIncorrectProtocolConfigValues = { // Protocols + {{InferenceEngine::MYRIAD_PROTOCOL, "0"}}, + {{InferenceEngine::MYRIAD_PROTOCOL, "2450"}}, + {{InferenceEngine::MYRIAD_PROTOCOL, "PCI"}}, + + // Deprecated {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), "0"}}, {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), "2450"}}, {{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), "PCI"}}, }; static const std::vector myriadCorrectConfigCombinationValues = { - {{VPU_MYRIAD_CONFIG_KEY(PLATFORM), ""}, - {VPU_MYRIAD_CONFIG_KEY(PROTOCOL), ""}} + {{InferenceEngine::MYRIAD_PROTOCOL, ""}, + // Deprecated + {VPU_MYRIAD_CONFIG_KEY(PROTOCOL), ""}} }; static const std::vector myriadIncorrectPowerConfigValues = { - {{VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), "-1"}}, - {{VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), "POWER_STANDARD"}}, - {{VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), "INFER"}}, - {{VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), ""}}, + {{InferenceEngine::MYRIAD_POWER_MANAGEMENT, "-1"}}, + {{InferenceEngine::MYRIAD_POWER_MANAGEMENT, "POWER_STANDARD"}}, + {{InferenceEngine::MYRIAD_POWER_MANAGEMENT, "INFER"}}, + {{InferenceEngine::MYRIAD_POWER_MANAGEMENT, ""}}, }; static const std::vector myriadCorrectPowerConfigValues = { - {{VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), VPU_MYRIAD_CONFIG_VALUE(POWER_FULL)}}, - {{VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), VPU_MYRIAD_CONFIG_VALUE(POWER_INFER)}}, - {{VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), VPU_MYRIAD_CONFIG_VALUE(POWER_STAGE)}}, - {{VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), VPU_MYRIAD_CONFIG_VALUE(POWER_STAGE_SHAVES)}}, - {{VPU_MYRIAD_CONFIG_KEY(POWER_MANAGEMENT), VPU_MYRIAD_CONFIG_VALUE(POWER_STAGE_NCES)}}, + {{InferenceEngine::MYRIAD_POWER_MANAGEMENT, InferenceEngine::MYRIAD_POWER_FULL}}, + {{InferenceEngine::MYRIAD_POWER_MANAGEMENT, InferenceEngine::MYRIAD_POWER_INFER}}, + {{InferenceEngine::MYRIAD_POWER_MANAGEMENT, InferenceEngine::MYRIAD_POWER_STAGE}}, + {{InferenceEngine::MYRIAD_POWER_MANAGEMENT, InferenceEngine::MYRIAD_POWER_STAGE_SHAVES}}, + {{InferenceEngine::MYRIAD_POWER_MANAGEMENT, InferenceEngine::MYRIAD_POWER_STAGE_NCES}}, }; static const std::vector myriadCorrectPackageTypeConfigValues = { + {{InferenceEngine::MYRIAD_DDR_TYPE, InferenceEngine::MYRIAD_DDR_AUTO}}, + {{InferenceEngine::MYRIAD_DDR_TYPE, InferenceEngine::MYRIAD_DDR_MICRON_2GB}}, + {{InferenceEngine::MYRIAD_DDR_TYPE, InferenceEngine::MYRIAD_DDR_SAMSUNG_2GB}}, + {{InferenceEngine::MYRIAD_DDR_TYPE, InferenceEngine::MYRIAD_DDR_HYNIX_2GB}}, + {{InferenceEngine::MYRIAD_DDR_TYPE, InferenceEngine::MYRIAD_DDR_MICRON_1GB}}, + + // Deprecated {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), VPU_MYRIAD_CONFIG_VALUE(DDR_AUTO)}}, {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), VPU_MYRIAD_CONFIG_VALUE(MICRON_2GB)}}, {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), VPU_MYRIAD_CONFIG_VALUE(SAMSUNG_2GB)}}, {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), VPU_MYRIAD_CONFIG_VALUE(HYNIX_2GB)}}, - {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), VPU_MYRIAD_CONFIG_VALUE(MICRON_1GB)}} + {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), VPU_MYRIAD_CONFIG_VALUE(MICRON_1GB)}}, }; static const std::vector myriadIncorrectPackageTypeConfigValues = { + {{InferenceEngine::MYRIAD_DDR_TYPE, "-1"}}, + {{InferenceEngine::MYRIAD_DDR_TYPE, "-MICRON_1GB"}}, + + // Deprecated {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), "-1"}}, {{VPU_MYRIAD_CONFIG_KEY(MOVIDIUS_DDR_TYPE), "-MICRON_1GB"}}, }; diff --git a/inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_metrics_tests.cpp b/inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_metrics_tests.cpp index c1877001816..a1d5fa4dadf 100644 --- a/inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_metrics_tests.cpp +++ b/inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_metrics_tests.cpp @@ -168,7 +168,7 @@ TEST_P(MyriadDeviceMetricsTestWithParam, CheckNames) { TEST_F(MyriadMetricsTest, ShouldThrowExceptionWhenOption_MYRIAD_THROUGHPUT_STREAMS_isInvalid) { range_type act_res; std::map config { - {KEY_VPU_MYRIAD_THROUGHPUT_STREAMS, std::string("bad param")} + {InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, std::string("bad param")} }; ASSERT_ANY_THROW(act_res = metrics_container_->RangeForAsyncInferRequests(config)); @@ -186,7 +186,7 @@ TEST_F(MyriadMetricsTest, ShouldReturnDefaultValueWhenOption_MYRIAD_THROUGHPUT_S TEST_P(MyriadRangeInferMetricsTestWithParam, CheckValues) { range_type act_res; std::map config { - {KEY_VPU_MYRIAD_THROUGHPUT_STREAMS, confir_param_} + {InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, confir_param_} }; ASSERT_NO_THROW(act_res = metrics_container_->RangeForAsyncInferRequests(config)); diff --git a/inference-engine/tools/compile_tool/README.md b/inference-engine/tools/compile_tool/README.md index fd4f0b943ac..1f95c7be21d 100644 --- a/inference-engine/tools/compile_tool/README.md +++ b/inference-engine/tools/compile_tool/README.md @@ -39,8 +39,6 @@ compile_tool [OPTIONS] Overwrites precision from ip and op options for specified layers. VPU options: - -VPU_MYRIAD_PLATFORM Optional. Specifies Movidius platform. Supported values: VPU_MYRIAD_2450, VPU_MYRIAD_2480. Overwrites value from config. - This option must be used in order to compile blob without a connected Myriad device. -VPU_NUMBER_OF_SHAVES Optional. Specifies number of shaves. Should be set with "VPU_NUMBER_OF_CMX_SLICES". Overwrites value from config. -VPU_NUMBER_OF_CMX_SLICES Optional. Specifies number of CMX slices. Should be set with "VPU_NUMBER_OF_SHAVES". Overwrites value from config. -VPU_TILING_CMX_LIMIT_KB Optional. Specifies CMX limit for data tiling in kB. Value should be equal or greater than -1, where -1 means default value of limit. Overwrites value from config. @@ -57,13 +55,6 @@ To dump a blob using a trained Faster R-CNN network, use the command below: ./compile_tool -m /model_name.xml ``` -## MYRIAD Platform Option - -You can dump a blob without a connected MYRIAD device. -To do that, specify the type of an Intel® Movidius™ platform using the `-VPU_MYRIAD_PLATFORM` parameter. - -Supported values: `VPU_MYRIAD_2450`, `VPU_MYRIAD_2480`. - ## FPGA Option You can compile executable network without a connected FPGA device with a loaded DLA bitstream. diff --git a/inference-engine/tools/compile_tool/main.cpp b/inference-engine/tools/compile_tool/main.cpp index e33297ef6de..2bc40c48bb5 100644 --- a/inference-engine/tools/compile_tool/main.cpp +++ b/inference-engine/tools/compile_tool/main.cpp @@ -15,6 +15,7 @@ #include #include "inference_engine.hpp" +#include #include #include #include "samples/common.hpp" @@ -28,11 +29,6 @@ static constexpr char targetDeviceMessage[] = "Required. Specify a target device static constexpr char output_message[] = "Optional. Path to the output file. Default value: \".blob\"."; static constexpr char config_message[] = "Optional. Path to the configuration file. Default value: \"config\"."; -static constexpr char platform_message[] = "Optional. Specifies Movidius platform." - " Supported values: VPU_MYRIAD_2450, VPU_MYRIAD_2480." - " Overwrites value from config.\n" -" This option must be used in order to compile blob" - " without a connected Myriad device."; static constexpr char number_of_shaves_message[] = "Optional. Specifies number of shaves." " Should be set with \"VPU_NUMBER_OF_CMX_SLICES\"." " Overwrites value from config."; @@ -70,7 +66,6 @@ DEFINE_string(op, "", outputs_precision_message); DEFINE_string(iop, "", iop_message); DEFINE_string(il, "", inputs_layout_message); DEFINE_string(ol, "", outputs_layout_message); -DEFINE_string(VPU_MYRIAD_PLATFORM, "", platform_message); DEFINE_string(VPU_NUMBER_OF_SHAVES, "", number_of_shaves_message); DEFINE_string(VPU_NUMBER_OF_CMX_SLICES, "", number_of_cmx_slices_message); DEFINE_string(VPU_TILING_CMX_LIMIT_KB, "", tiling_cmx_limit_message); @@ -92,7 +87,6 @@ static void showUsage() { std::cout << " -ol " << outputs_layout_message << std::endl; std::cout << " " << std::endl; std::cout << " VPU options: " << std::endl; - std::cout << " -VPU_MYRIAD_PLATFORM " << platform_message << std::endl; std::cout << " -VPU_NUMBER_OF_SHAVES " << number_of_shaves_message << std::endl; std::cout << " -VPU_NUMBER_OF_CMX_SLICES " << number_of_cmx_slices_message << std::endl; std::cout << " -VPU_TILING_CMX_LIMIT_KB " << tiling_cmx_limit_message << std::endl; @@ -117,10 +111,10 @@ static bool parseCommandLine(int *argc, char ***argv, InferenceEngine::Core& ie) throw std::invalid_argument("Target device name is required"); } - if (std::string::npos != FLAGS_d.find("MYRIAD") && FLAGS_VPU_MYRIAD_PLATFORM.empty()) { + if (std::string::npos != FLAGS_d.find("MYRIAD")) { std::vector myriadDeviceIds = ie.GetMetric("MYRIAD", METRIC_KEY(AVAILABLE_DEVICES)); if (myriadDeviceIds.empty()) { - throw std::runtime_error{"No available MYRIAD devices. Please specify -VPU_MYRIAD_PLATFORM option explicitly"}; + throw std::runtime_error{"No available MYRIAD devices"}; } } @@ -157,20 +151,16 @@ static std::map parseConfig(const std::string& configN static std::map configure(const std::string &configFile, const std::string &xmlFileName) { auto config = parseConfig(configFile); - if (!FLAGS_VPU_MYRIAD_PLATFORM.empty()) { - config[VPU_MYRIAD_CONFIG_KEY(PLATFORM)] = FLAGS_VPU_MYRIAD_PLATFORM; - } - if (!FLAGS_VPU_NUMBER_OF_SHAVES.empty()) { - config[VPU_CONFIG_KEY(NUMBER_OF_SHAVES)] = FLAGS_VPU_NUMBER_OF_SHAVES; + config[InferenceEngine::MYRIAD_NUMBER_OF_SHAVES] = FLAGS_VPU_NUMBER_OF_SHAVES; } if (!FLAGS_VPU_NUMBER_OF_CMX_SLICES.empty()) { - config[VPU_CONFIG_KEY(NUMBER_OF_CMX_SLICES)] = FLAGS_VPU_NUMBER_OF_CMX_SLICES; + config[InferenceEngine::MYRIAD_NUMBER_OF_CMX_SLICES] = FLAGS_VPU_NUMBER_OF_CMX_SLICES; } if (!FLAGS_VPU_TILING_CMX_LIMIT_KB.empty()) { - config[VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB)] = FLAGS_VPU_TILING_CMX_LIMIT_KB; + config[InferenceEngine::MYRIAD_TILING_CMX_LIMIT_KB] = FLAGS_VPU_TILING_CMX_LIMIT_KB; } if (!FLAGS_DLA_ARCH_NAME.empty()) { diff --git a/inference-engine/tools/vpu/vpu_compile/README.md b/inference-engine/tools/vpu/vpu_compile/README.md index 285b59bf5e9..dddec447cd0 100644 --- a/inference-engine/tools/vpu/vpu_compile/README.md +++ b/inference-engine/tools/vpu/vpu_compile/README.md @@ -32,8 +32,6 @@ myriad_compile [OPTIONS] Example: -iop "input:FP16, output:FP16". Notice that quotes are required. Overwrites precision from ip and op options for specified layers. - -VPU_MYRIAD_PLATFORM Optional. Specifies movidius platform. Supported values: VPU_MYRIAD_2450, VPU_MYRIAD_2480. Overwrites value from config. - This option must be used in order to compile blob without a connected Myriad device. -VPU_NUMBER_OF_SHAVES Optional. Specifies number of shaves. Should be set with "VPU_NUMBER_OF_CMX_SLICES". Overwrites value from config. -VPU_NUMBER_OF_CMX_SLICES Optional. Specifies number of CMX slices. Should be set with "VPU_NUMBER_OF_SHAVES". Overwrites value from config. -VPU_TILING_CMX_LIMIT_KB Optional. Specifies CMX limit for data tiling in kB. Value should be equal or greater than -1, where -1 means default value of limit. Overwrites value from config. @@ -47,12 +45,6 @@ You can use the following command to dump blob using a trained Faster R-CNN netw ./myriad_compile -m /model_name.xml ``` -## Platform option - -You can dump blob without a connected Myriad device. -To do that, you must specify type of movidius platform using the parameter -VPU_MYRIAD_PLATFORM. -Supported values: VPU_MYRIAD_2450, VPU_MYRIAD_2480 - ## Import and Export functionality #### Export diff --git a/inference-engine/tools/vpu/vpu_compile/main.cpp b/inference-engine/tools/vpu/vpu_compile/main.cpp index 37121548661..5ad660db63a 100644 --- a/inference-engine/tools/vpu/vpu_compile/main.cpp +++ b/inference-engine/tools/vpu/vpu_compile/main.cpp @@ -25,11 +25,6 @@ static constexpr char model_message[] = "Required. Path to xml model."; static constexpr char plugin_path_message[] = "Optional. Path to a plugin folder."; static constexpr char output_message[] = "Optional. Path to the output file. Default value: \".blob\"."; static constexpr char config_message[] = "Optional. Path to the configuration file. Default value: \"config\"."; -static constexpr char platform_message[] = "Optional. Specifies movidius platform." - " Supported values: VPU_MYRIAD_2450, VPU_MYRIAD_2480." - " Overwrites value from config.\n" -" This option must be used in order to compile blob" - " without a connected Myriad device."; static constexpr char number_of_shaves_message[] = "Optional. Specifies number of shaves." " Should be set with \"VPU_NUMBER_OF_CMX_SLICES\"." " Overwrites value from config."; @@ -58,7 +53,6 @@ DEFINE_string(c, "config", config_message); DEFINE_string(ip, "", inputs_precision_message); DEFINE_string(op, "", outputs_precision_message); DEFINE_string(iop, "", iop_message); -DEFINE_string(VPU_MYRIAD_PLATFORM, "", platform_message); DEFINE_string(VPU_NUMBER_OF_SHAVES, "", number_of_shaves_message); DEFINE_string(VPU_NUMBER_OF_CMX_SLICES, "", number_of_cmx_slices_message); DEFINE_string(VPU_TILING_CMX_LIMIT_KB, "", tiling_cmx_limit_message); @@ -75,7 +69,6 @@ static void showUsage() { std::cout << " -ip " << inputs_precision_message << std::endl; std::cout << " -op " << outputs_precision_message << std::endl; std::cout << " -iop \"\" " << iop_message << std::endl; - std::cout << " -VPU_MYRIAD_PLATFORM " << platform_message << std::endl; std::cout << " -VPU_NUMBER_OF_SHAVES " << number_of_shaves_message << std::endl; std::cout << " -VPU_NUMBER_OF_CMX_SLICES " << number_of_cmx_slices_message << std::endl; std::cout << " -VPU_TILING_CMX_LIMIT_KB " << tiling_cmx_limit_message << std::endl; @@ -112,20 +105,16 @@ static bool parseCommandLine(int *argc, char ***argv) { static std::map configure(const std::string &configFile, const std::string &xmlFileName) { auto config = parseConfig(configFile); - if (!FLAGS_VPU_MYRIAD_PLATFORM.empty()) { - config[VPU_MYRIAD_CONFIG_KEY(PLATFORM)] = FLAGS_VPU_MYRIAD_PLATFORM; - } - if (!FLAGS_VPU_NUMBER_OF_SHAVES.empty()) { - config[VPU_CONFIG_KEY(NUMBER_OF_SHAVES)] = FLAGS_VPU_NUMBER_OF_SHAVES; + config[InferenceEngine::MYRIAD_NUMBER_OF_SHAVES] = FLAGS_VPU_NUMBER_OF_SHAVES; } if (!FLAGS_VPU_NUMBER_OF_CMX_SLICES.empty()) { - config[VPU_CONFIG_KEY(NUMBER_OF_CMX_SLICES)] = FLAGS_VPU_NUMBER_OF_CMX_SLICES; + config[InferenceEngine::MYRIAD_NUMBER_OF_CMX_SLICES] = FLAGS_VPU_NUMBER_OF_CMX_SLICES; } if (!FLAGS_VPU_TILING_CMX_LIMIT_KB.empty()) { - config[VPU_CONFIG_KEY(TILING_CMX_LIMIT_KB)] = FLAGS_VPU_TILING_CMX_LIMIT_KB; + config[InferenceEngine::MYRIAD_TILING_CMX_LIMIT_KB] = FLAGS_VPU_TILING_CMX_LIMIT_KB; } return config; diff --git a/inference-engine/tools/vpu/vpu_perfcheck/main.cpp b/inference-engine/tools/vpu/vpu_perfcheck/main.cpp index e3cf4e5f144..97261e8e794 100644 --- a/inference-engine/tools/vpu/vpu_perfcheck/main.cpp +++ b/inference-engine/tools/vpu/vpu_perfcheck/main.cpp @@ -33,7 +33,7 @@ #include #include -#include +#include static char* m_exename = nullptr; @@ -155,8 +155,8 @@ static bool loadBinaryTensor(const std::string &binaryFilename, InferenceEngine: static void setConfig(std::map& config, const std::string& file_config_cl) { config[CONFIG_KEY(LOG_LEVEL)] = CONFIG_VALUE(LOG_WARNING); - config[VPU_CONFIG_KEY(PRINT_RECEIVE_TENSOR_TIME)] = CONFIG_VALUE(YES); - config[VPU_CONFIG_KEY(CUSTOM_LAYERS)] = file_config_cl; + config[InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME] = CONFIG_VALUE(YES); + config[InferenceEngine::MYRIAD_CUSTOM_LAYERS] = file_config_cl; } static void printPerformanceCounts(const std::map& perfMap) {