natas_hw
/
openvino
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[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
This commit is contained in:
Maksim Doronin 2020-08-17 17:30:38 +03:00 committed by GitHub
parent 125a462400
commit 66aa119b11
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
103 changed files with 991 additions and 556 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
inference-engine/include/vpu/hddl_config.hpp Normal file
View File

@ -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<std::string> of device names, String value is METRIC_HDDL_DEVICE_NAME
*/
DECLARE_METRIC_KEY(HDDL_DEVICE_NAME, std::vector<std::string>);
/**
* @brief Metric to get a std::vector<float> of device thermal, String value is METRIC_HDDL_DEVICE_THERMAL
*/
DECLARE_METRIC_KEY(HDDL_DEVICE_THERMAL, std::vector<float>);
/**
* @brief Metric to get a std::vector<uint32> of device ids, String value is METRIC_HDDL_DEVICE_ID
*/
DECLARE_METRIC_KEY(HDDL_DEVICE_ID, std::vector<unsigned int>);
/**
* @brief Metric to get a std::vector<int> of device subclasses, String value is METRIC_HDDL_DEVICE_SUBCLASS
*/
DECLARE_METRIC_KEY(HDDL_DEVICE_SUBCLASS, std::vector<int>);
/**
* @brief Metric to get a std::vector<uint32> of device total memory, String value is METRIC_HDDL_MEMORY_TOTAL
*/
DECLARE_METRIC_KEY(HDDL_DEVICE_MEMORY_TOTAL, std::vector<unsigned int>);
/**
* @brief Metric to get a std::vector<uint32> of device used memory, String value is METRIC_HDDL_DEVICE_MEMORY_USED
*/
DECLARE_METRIC_KEY(HDDL_DEVICE_MEMORY_USED, std::vector<unsigned int>);
/**
* @brief Metric to get a std::vector<float> of device utilization, String value is METRIC_HDDL_DEVICE_UTILIZATION
*/
DECLARE_METRIC_KEY(HDDL_DEVICE_UTILIZATION, std::vector<float>);
/**
* @brief Metric to get a std::vector<std::string> of stream ids, String value is METRIC_HDDL_DEVICE_STREAM_ID
*/
DECLARE_METRIC_KEY(HDDL_STREAM_ID, std::vector<std::string>);
/**
* @brief Metric to get a std::vector<std::string> of device tags, String value is METRIC_HDDL_DEVICE_TAG
*/
DECLARE_METRIC_KEY(HDDL_DEVICE_TAG, std::vector<std::string>);
/**
* @brief Metric to get a std::vector<int> of group ids, String value is METRIC_HDDL_GROUP_ID
*/
DECLARE_METRIC_KEY(HDDL_GROUP_ID, std::vector<int>);
/**
* @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

44
inference-engine/include/vpu/hddl_plugin_config.hpp
View File

@ -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<std::string> 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<std::string>);
/**
* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_THERMAL instead
* @brief Metric to get a std::vector<float> 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<float>);
/**
* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_ID instead
* @brief Metric to get a std::vector<uint32> 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<unsigned int>);
/**
* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_SUBCLASS instead
* @brief Metric to get a std::vector<int> 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<int>);
/**
* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_MEMORY_TOTAL instead
* @brief Metric to get a std::vector<uint32> 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<unsigned int>);
/**
* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_MEMORY_USED instead
* @brief Metric to get a std::vector<uint32> 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<unsigned int>);
/**
* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_UTILIZATION instead
* @brief Metric to get a std::vector<float> 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<float>);
/**
* @deprecated Use InferenceEngine::METRIC_HDDL_STREAM_ID instead
* @brief Metric to get a std::vector<std::string> 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<std::string>);
/**
* @deprecated Use InferenceEngine::METRIC_HDDL_DEVICE_TAG instead
* @brief Metric to get a std::vector<std::string> 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<std::string>);
/**
* @deprecated Use InferenceEngine::METRIC_HDDL_GROUP_ID instead
* @brief Metric to get a std::vector<int> 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<int>);
/**
* @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

62
inference-engine/include/vpu/myriad_config.hpp Normal file
View File

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

19
inference-engine/include/vpu/myriad_plugin_config.hpp
View File

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

50
inference-engine/include/vpu/vpu_config.hpp Normal file
View File

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

54
inference-engine/include/vpu/vpu_plugin_config.hpp
View File

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

2
inference-engine/src/vpu/graph_transformer/include/vpu/parsed_config.hpp
View File

@ -9,7 +9,7 @@
#include <unordered_set>
#include <string>
#include <vpu/vpu_plugin_config.hpp>
#include <vpu/myriad_config.hpp>
#include <vpu/private_plugin_config.hpp>
#include <vpu/parsed_config_base.hpp>

90
inference-engine/src/vpu/graph_transformer/include/vpu/private_plugin_config.hpp
View File

@ -6,103 +6,109 @@
#include <string>
#include <vpu/myriad_config.hpp>
#include <vpu/vpu_plugin_config.hpp>
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

10
inference-engine/src/vpu/graph_transformer/src/graph_transformer.cpp
View File

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

168
inference-engine/src/vpu/graph_transformer/src/parsed_config.cpp
View File

@ -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<std::string>& ParsedConfig::getRunTimeOptions() const {
IE_SUPPRESS_DEPRECATED_START
static const std::unordered_set<std::string> 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<std::string>& ParsedConfig::getRunTimeOptions() const {
const std::unordered_set<std::string>& ParsedConfig::getDeprecatedOptions() const {
IE_SUPPRESS_DEPRECATED_START
static const std::unordered_set<std::string> 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<std::string, std::string>& config) {
static const std::unordered_map<std::string, PerfReport> 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<std::string, std::string>& 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<std::string, std::string>& 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

106
inference-engine/src/vpu/myriad_plugin/myriad_config.cpp
View File

@ -12,6 +12,7 @@
#include <cpp_interfaces/exception2status.hpp>
#include <vpu/vpu_plugin_config.hpp>
#include <vpu/myriad_config.hpp>
namespace vpu {
namespace MyriadPlugin {
@ -20,7 +21,6 @@ const std::unordered_set<std::string>& MyriadConfig::getCompileOptions() const {
IE_SUPPRESS_DEPRECATED_START
static const std::unordered_set<std::string> 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<std::string> 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<std::string>& MyriadConfig::getDeprecatedOptions() const {
IE_SUPPRESS_DEPRECATED_START
static const std::unordered_set<std::string> 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<std::string, std::string>& config) {
static const std::unordered_map<std::string, ncDevicePlatform_t> 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<std::string, ncDevicePlatform_t> 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<std::string, ncDevicePlatform_t> 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<std::string, ncDeviceProtocol_t> 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<std::string, MovidiusDdrType> 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<std::string, ncDeviceProtocol_t> 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<std::string, std::chrono::milliseconds> watchdogIntervals = {
@ -90,36 +103,37 @@ IE_SUPPRESS_DEPRECATED_END
};
static const std::unordered_map<std::string, PowerConfig> 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<std::string, MovidiusDdrType> 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

26
inference-engine/src/vpu/myriad_plugin/myriad_metrics.cpp
View File

@ -9,8 +9,9 @@
#include <vpu/utils/error.hpp>
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<std::string>& MyriadMetrics::OptimizationCapabilities()
RangeType MyriadMetrics::RangeForAsyncInferRequests(
const std::map<std::string, std::string>& 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";
}
}

21
inference-engine/src/vpu/myriad_plugin/myriad_plugin.cpp
View File

@ -130,18 +130,27 @@ Engine::Engine(std::shared_ptr<IMvnc> 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(

72
inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/config.cpp
View File

@ -14,8 +14,8 @@ namespace {
};
const std::vector<std::map<std::string, std::string>> 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<std::map<std::string, std::string>> 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<std::map<std::string, std::string>> 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<std::map<std::string, std::string>> 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
} // namespace

35
inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/infer_request_config.cpp
View File

@ -23,8 +23,8 @@ namespace {
const std::vector<std::map<std::string, std::string>> 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<std::map<std::string, std::string>> 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,

4
inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/eltwise.cpp
View File

@ -48,9 +48,9 @@ std::vector<ngraph::helpers::EltwiseTypes> 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;
}

4
inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/nonzero.cpp
View File

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

2
inference-engine/tests/functional/plugin/myriad/shared_tests_instances/single_layer_tests/strided_slice.cpp
View File

@ -43,7 +43,7 @@ std::vector<InferenceEngine::Precision> 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;
}

4
inference-engine/tests/functional/plugin/myriad/single_layer_tests/out_shape_of_reshape.cpp
View File

@ -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();

2
inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_broadcast.cpp
View File

@ -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();

4
inference-engine/tests/functional/plugin/myriad/single_layer_tests/static_shape_nonzero.cpp
View File

@ -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();

4
inference-engine/tests/functional/plugin/myriad/subgraph_tests/dsr_tests_common.hpp
View File

@ -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();

4
inference-engine/tests/functional/plugin/myriad/subgraph_tests/nonzero_broadcast.cpp
View File

@ -23,10 +23,10 @@ class NonZero_Broadcast : public testing::WithParamInterface<BroadcastExplicitTe
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);
// DISABLE_REORDER is needed for Myriad2 cases
if (CommonTestUtils::vpu::CheckMyriad2()) {
configuration[VPU_CONFIG_KEY(DISABLE_REORDER)] = CONFIG_VALUE(YES);
configuration[InferenceEngine::MYRIAD_DISABLE_REORDER] = CONFIG_VALUE(YES);
}
const auto& parameters = GetParam();

6
inference-engine/tests_deprecated/behavior/vpu/myriad_tests/helpers/myriad_protocol_case.cpp
View File

@ -23,13 +23,13 @@ std::map<std::string, std::string> 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 {};
}

4
inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_boot_tests.cpp
View File

@ -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);
}

2
inference-engine/tests_deprecated/behavior/vpu/myriad_tests/vpu_watchdog_tests.cpp
View File

@ -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();

88
inference-engine/tests_deprecated/behavior/vpu/shared_tests_instances/plugin_tests/vpu_test_data.hpp
View File

@ -77,16 +77,20 @@ const BehTestParams allUnSupportedValues[] = {
};
const std::vector<BehTestParams> 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<BehTestParams> 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<BehTestParams> 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<BehTestParams> 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[] = {

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_CTCDecoder_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_bias_test.hpp
View File

@ -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();

27
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_blob_test.cpp
View File

@ -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<std::string, std::string> 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<std::string, std::string> 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<std::string, std::string> 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<InferenceEngine::Precision> outputPrecisions = {Inferen
INSTANTIATE_TEST_CASE_P(accuracy, myriadBlobExportAccuracyDifferentPrecisionOfInAndOutTests_smoke,
::testing::Combine(::testing::ValuesIn(inputPrecisions), ::testing::ValuesIn(outputPrecisions)));
::testing::Combine(::testing::ValuesIn(inputPrecisions), ::testing::ValuesIn(outputPrecisions)));

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_clamp_test.hpp
View File

@ -21,7 +21,7 @@ struct clamp_test_params {
typedef myriadLayerTestBaseWithParam<std::tuple<SizeVector, clamp_test_params>> 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);

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_conv_nd_test.hpp
View File

@ -51,8 +51,8 @@ class ConvNDTest: public myriadLayerTestBaseWithParam<ConvNDTestParams>
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

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convert_test.hpp
View File

@ -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});

8
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution1x1.hpp
View File

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

10
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution3x3.hpp
View File

@ -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<dims_config_con3x3> 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
};
};

12
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_convolution_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_copy_test.hpp
View File

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

16
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_custom_test.hpp
View File

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

8
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_deconvolution_test.hpp
View File

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

28
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.cpp
View File

@ -255,7 +255,7 @@ TEST_F(myriadLayersTestsEltwiseBase, EltwiseWithSameInputs) {
InferenceEngine::Blob::Ptr inputBlob;
InferenceEngine::IExecutableNetwork::Ptr exeNetwork;
std::map<std::string, std::string> networkConfig = {{VPU_CONFIG_KEY(PERF_REPORT_MODE), VPU_CONFIG_VALUE(PER_STAGE)}};
std::map<std::string, std::string> 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;

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_eltwise_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_elu_test.hpp
View File

@ -32,7 +32,7 @@ void gen_ref_elu(const InferenceEngine::Blob::Ptr src,
typedef myriadLayerTestBaseWithParam<std::tuple<SizeVector, alpha>> 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);

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_erf_test.hpp
View File

@ -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<SizeVector>::GetParam();
SetInputTensors({p});
SetOutputTensors({p});

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_detectionoutput_test.hpp
View File

@ -154,7 +154,7 @@ class ExpDetectionOutputTest: public myriadLayerTestBaseWithParam<ExpDetectionOu
protected:
void testExpDetectionOutput()
{
_config[VPU_CONFIG_KEY(DETECT_NETWORK_BATCH)] = CONFIG_VALUE(NO);
_config[InferenceEngine::MYRIAD_DETECT_NETWORK_BATCH] = CONFIG_VALUE(NO);
const auto testParams = GetParam();
const auto sizeParams = std::get<0>(testParams);

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_generateproposals_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_priorgridgenerator_test.hpp
View File

@ -76,7 +76,7 @@ class myriadLayersTestsExpPriorGridGen : public myriadLayerTestBaseWithParam<Exp
const auto numPriors = inputTensorsDims.priors.n;
_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({inputTensorsDims.priors.n, inputTensorsDims.priors.c});

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_exp_topkrois_test.hpp
View File

@ -105,7 +105,7 @@ TEST_P(myriadLayersTestsExpTopKROIs_smoke, ExpTopKROIs) {
int inputRoisNum = std::get<0>(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<size_t>(inputRoisNum), NUM_COORDS}); // input rois

8
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_fully_connected_tests.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gather_test.hpp
View File

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

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_gemm_test.hpp
View File

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

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_grn_test.hpp
View File

@ -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<CustomConfig> s_CustomConfig = {
static std::vector<SizeVector> s_GRNInputs = {
{1, 3, 16, 224},
{1, 24, 128, 224},
};
};

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.cpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_mvn_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_nonzero_test.hpp
View File

@ -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();

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_oneHot_test.hpp
View File

@ -54,7 +54,7 @@ void ref_oneHot(const InferenceEngine::Blob::Ptr src,
typedef myriadLayerTestBaseWithParam<oneHot_test_params> 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();

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_nd_test.hpp
View File

@ -91,7 +91,7 @@ TEST_P(myriadLayersPermuteNDTests_smoke, Permute) {
const std::map<std::string, std::string> 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<InferenceEngine::SizeVector> s_permuteTensors_5D = {
static const std::vector<InferenceEngine::Precision> s_permutePrecisions = {
InferenceEngine::Precision::I32,
InferenceEngine::Precision::FP16,
};
};

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_permute_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pool_nd_test.hpp
View File

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

8
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_pooling_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_power_test.hpp
View File

@ -42,7 +42,7 @@ static void gen_ref_power(const InferenceEngine::Blob::Ptr src,
typedef myriadLayerTestBaseWithParam<std::tuple<SizeVector, pwr_test_params>> 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);

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_prelu_test.hpp
View File

@ -15,7 +15,7 @@ PRETTY_PARAM(ChannelSharedPrelu, int);
typedef myriadLayerTestBaseWithParam<tuple<SizeVector, ChannelSharedPrelu >> 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());

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reduce_test.hpp
View File

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

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_region_test.hpp
View File

@ -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<CustomConfig> s_CustomConfig = {
#ifdef VPU_HAS_CUSTOM_KERNELS
getIELibraryPath() + "/vpu_custom_kernels/customLayerBindings.xml"
#endif
};
};

7
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_relu_test.hpp
View File

@ -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<ReLULayerDef> s_reluLayerParams = {
typedef myriadLayerTestBaseWithParam<std::tuple<InferenceEngine::SizeVector, ReLULayerDef>> 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;

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reorg_test.hpp
View File

@ -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<SizeVector> s_ReorgInputs = {
{1, 64, 26, 26},
{1, 192, 6 * 26, 6 * 26},
{1, 4, 6, 6}
};
};

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_resample_test.hpp
View File

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

13
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.cpp
View File

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

8
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reshape_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_reverse_sequence_test.hpp
View File

@ -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());

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_align_test.hpp
View File

@ -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<number_rois> s_ROIAlignNumROIs = {
static std::vector<roi_align_mode> s_ROIAlignMode = {
std::string("avg"),
std::string("max")
};
};

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_roi_feature_extractor_test.hpp
View File

@ -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});

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scale_test.hpp
View File

@ -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<TestScaleShift>::GetParam());
bool biasAdd = std::get<1>(::testing::WithParamInterface<TestScaleShift>::GetParam());

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_elements_update_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_scatter_update_test.hpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_select_test.hpp
View File

@ -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());

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_sigmoid_test.hpp
View File

@ -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});

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_slice_test.hpp
View File

@ -19,7 +19,7 @@ PRETTY_PARAM(SliceTestParams, SliceParams);
typedef myriadLayerTestBaseWithParam<SliceTestParams> 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();

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_softmax_test.hpp
View File

@ -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});

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_split_test.hpp
View File

@ -19,7 +19,7 @@ PRETTY_PARAM(SplitTestParams, SplitParams);
typedef myriadLayerTestBaseWithParam<SplitTestParams> 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();

4
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_strided_slice_test.h
View File

@ -242,10 +242,10 @@ TEST_P(myriadLayersTestsStridedSlice_smoke, TestsStridedSlice) {
StatusCode st = GENERAL_ERROR;
std::map<std::string, std::string> 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(

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tanh_test.hpp
View File

@ -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<SizeVector>::GetParam();
SetInputTensors({p});
SetOutputTensors({p});

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_tile_test.hpp
View File

@ -109,7 +109,7 @@ void ref_tile(const InferenceEngine::Blob::Ptr src,
typedef myriadLayerTestBaseWithParam<tuple<test_params, tiles>> 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());

2
inference-engine/tests_deprecated/functional/vpu/common/layers/myriad_layers_topk_test.hpp
View File

@ -33,7 +33,7 @@ class TopKTest: public myriadLayerTestBaseWithParam<TopKTestParams>
{
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;

2
inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_conv_tests.hpp
View File

@ -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() {

6
inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_extra_tests.hpp
View File

@ -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)
},
},

2
inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_fc_tests.hpp
View File

@ -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() {

4
inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_network_tests.hpp
View File

@ -73,9 +73,9 @@ public:
const int NUM_REQUESTS = 4;
std::map<std::string, std::string> 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;

2
inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_pool_tests.hpp
View File

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

4
inference-engine/tests_deprecated/functional/vpu/common/myriad_hw_tests_base.hpp
View File

@ -126,10 +126,10 @@ public:
StatusCode st;
std::map<std::string, std::string> 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 }
};

4
inference-engine/tests_deprecated/functional/vpu/common/myriad_merge_permute_tests.hpp
View File

@ -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();

28
inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_configs_tests.cpp
View File

@ -84,45 +84,37 @@ TEST_P(myriadIncorrectModelsConfigsTests_nightly, LoadNetworkWithIncorrectConfig
static const std::vector<config_t> 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<config_t> 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<config_t> 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<config_t> 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));

2
inference-engine/tests_deprecated/functional/vpu/myriad_tests/myriad_streams_configuration_tests.cpp
View File

@ -11,7 +11,7 @@ namespace {
class myriadCorrectStreamsConfiguration_nightly : public vpuLayersTests, public testing::WithParamInterface<std::uint32_t> {};
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();

4
inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.cpp
View File

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

2
inference-engine/tests_deprecated/functional/vpu/vpu_base/myriad_layers_tests.hpp
View File

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

10
inference-engine/tests_deprecated/functional/vpu/vpu_base/vpu_layers_tests.cpp
View File

@ -175,16 +175,16 @@ void vpuLayersTests::createInferRequest(const NetworkParams& params) {
std::map<std::string, std::string> 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";
}

17
inference-engine/tests_deprecated/helpers/tests_vpu_common.hpp
View File

@ -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() {

67
inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_engine_tests.cpp
View File

@ -20,33 +20,25 @@ TEST_P(MyriadEngineSetIncorrectConfigTest, SetIncorrectConfig) {
IE_SUPPRESS_DEPRECATED_START
static const std::vector<config_t> 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<config_t> 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<config_t> 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<config_t> myriadCorrectProtocolConfigValues = {
static const std::vector<config_t> 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<config_t> myriadCorrectConfigCombinationValues = {
{{VPU_MYRIAD_CONFIG_KEY(PLATFORM), ""},
{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), ""}}
{{InferenceEngine::MYRIAD_PROTOCOL, ""},
// Deprecated
{VPU_MYRIAD_CONFIG_KEY(PROTOCOL), ""}}
};
static const std::vector<config_t> 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<config_t> 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<config_t> 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<config_t> 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"}},
};

4
inference-engine/tests_deprecated/unit/engines/vpu/myriad_tests/myriad_metrics_tests.cpp
View File

@ -168,7 +168,7 @@ TEST_P(MyriadDeviceMetricsTestWithParam, CheckNames) {
TEST_F(MyriadMetricsTest, ShouldThrowExceptionWhenOption_MYRIAD_THROUGHPUT_STREAMS_isInvalid) {
range_type act_res;
std::map<std::string, std::string> 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<std::string, std::string> config {
{KEY_VPU_MYRIAD_THROUGHPUT_STREAMS, confir_param_}
{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, confir_param_}
};
ASSERT_NO_THROW(act_res = metrics_container_->RangeForAsyncInferRequests(config));

9
inference-engine/tools/compile_tool/README.md
View File

@ -39,8 +39,6 @@ compile_tool [OPTIONS]
Overwrites precision from ip and op options for specified layers.
VPU options:
-VPU_MYRIAD_PLATFORM <value> 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 <value> Optional. Specifies number of shaves. Should be set with "VPU_NUMBER_OF_CMX_SLICES". Overwrites value from config.
-VPU_NUMBER_OF_CMX_SLICES <value> Optional. Specifies number of CMX slices. Should be set with "VPU_NUMBER_OF_SHAVES". Overwrites value from config.
-VPU_TILING_CMX_LIMIT_KB <value> 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 <path_to_model>/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.

22
inference-engine/tools/compile_tool/main.cpp
View File

@ -15,6 +15,7 @@
#include <gflags/gflags.h>
#include "inference_engine.hpp"
#include <vpu/vpu_plugin_config.hpp>
#include <vpu/private_plugin_config.hpp>
#include <vpu/utils/string.hpp>
#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: \"<model_xml_file>.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 <value> " << outputs_layout_message << std::endl;
std::cout << " " << std::endl;
std::cout << " VPU options: " << std::endl;
std::cout << " -VPU_MYRIAD_PLATFORM <value> " << platform_message << std::endl;
std::cout << " -VPU_NUMBER_OF_SHAVES <value> " << number_of_shaves_message << std::endl;
std::cout << " -VPU_NUMBER_OF_CMX_SLICES <value> " << number_of_cmx_slices_message << std::endl;
std::cout << " -VPU_TILING_CMX_LIMIT_KB <value> " << 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<std::string> 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<std::string, std::string> parseConfig(const std::string& configN
static std::map<std::string, std::string> 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()) {

Some files were not shown because too many files have changed in this diff Show More