[IE][VPU]: Completion of Configuration options refactoring in VPU plugins

inference-engine/include/vpu/myriad_config.hpp

@@ -59,4 +59,9 @@ DECLARE_VPU_CONFIG(MYRIAD_USB);
  */
 DECLARE_VPU_CONFIG(MYRIAD_THROUGHPUT_STREAMS);
 
+/**
+ * @brief Default key definition for InferenceEngine::MYRIAD_THROUGHPUT_STREAMS option.
+ */
+DECLARE_VPU_CONFIG(MYRIAD_THROUGHPUT_STREAMS_AUTO);
+
 }  // namespace InferenceEngine

inference-engine/src/vpu/common/CMakeLists.txt

@@ -53,7 +53,7 @@ function(add_common_target TARGET_NAME STATIC_IE)
     openvino_developer_export_targets(COMPONENT inference_engine_vpu TARGETS ${TARGET_NAME})
 
     target_link_libraries(${TARGET_NAME} PUBLIC ngraph inference_engine_transformations
-                                         PRIVATE openvino::itt)
+                                         PRIVATE mvnc openvino::itt)
 
     if(NOT STATIC_IE)
         target_link_libraries(${TARGET_NAME} PUBLIC inference_engine_legacy)

inference-engine/src/vpu/common/include/vpu/configuration/options/check_preprocessing_inside_model.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <string>
+
+#include "vpu/configuration/as_parameter_enabler.hpp"
+
+namespace vpu {
+
+namespace details {
+
+enum class Access;
+enum class Category;
+
+}  // namespace details
+
+class PluginConfiguration;
+
+struct CheckPreprocessingInsideModelOption : public AsParsedParameterEnabler<CheckPreprocessingInsideModelOption> {
+    using value_type = bool;
+
+    static std::string key();
+    static void validate(const std::string&);
+    static void validate(const PluginConfiguration&);
+    static std::string defaultValue();
+    static value_type parse(const std::string&);
+    static details::Access access();
+    static details::Category category();
+};
+
+}  // namespace vpu

inference-engine/src/vpu/common/include/vpu/configuration/options/config_file.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <string>
+
+#include "vpu/configuration/as_parameter_enabler.hpp"
+
+namespace vpu {
+
+namespace details {
+
+enum class Access;
+enum class Category;
+
+}  // namespace details
+
+class PluginConfiguration;
+
+struct ConfigFileOption : public AsParameterEnabler {
+    using value_type = std::string;
+
+    static std::string key();
+    static void validate(const std::string&);
+    static void validate(const PluginConfiguration&);
+    static std::string defaultValue();
+    static value_type parse(const std::string&);
+    static details::Access access();
+    static details::Category category();
+};
+
+}  // namespace vpu

inference-engine/src/vpu/common/include/vpu/configuration/options/custom_layers.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <string>
+
+#include "vpu/configuration/as_parameter_enabler.hpp"
+
+namespace vpu {
+
+namespace details {
+
+enum class Access;
+enum class Category;
+
+}  // namespace details
+
+class PluginConfiguration;
+
+struct CustomLayersOption : public AsParameterEnabler {
+    using value_type = std::string;
+
+    static std::string key();
+    static void validate(const std::string&);
+    static void validate(const PluginConfiguration&);
+    static std::string defaultValue();
+    static value_type parse(const std::string&);
+    static details::Access access();
+    static details::Category category();
+};
+
+}  // namespace vpu

inference-engine/src/vpu/common/include/vpu/configuration/options/detect_network_batch.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <string>
+
+#include "vpu/configuration/as_parameter_enabler.hpp"
+
+namespace vpu {
+
+namespace details {
+
+enum class Access;
+enum class Category;
+
+}  // namespace details
+
+class PluginConfiguration;
+
+struct DetectNetworkBatchOption : public AsParsedParameterEnabler<DetectNetworkBatchOption> {
+    using value_type = bool;
+
+    static std::string key();
+    static void validate(const std::string&);
+    static void validate(const PluginConfiguration&);
+    static std::string defaultValue();
+    static value_type parse(const std::string&);
+    static details::Access access();
+    static details::Category category();
+};
+
+}  // namespace vpu

inference-engine/src/vpu/common/include/vpu/configuration/options/device_connect_timeout.hpp

@@ -0,0 +1,35 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <string>
+#include <chrono>
+
+#include "vpu/configuration/as_parameter_enabler.hpp"
+
+namespace vpu {
+
+namespace details {
+
+enum class Access;
+enum class Category;
+
+}  // namespace details
+
+class PluginConfiguration;
+
+struct DeviceConnectTimeoutOption : public AsParsedParameterEnabler<DeviceConnectTimeoutOption> {
+    using value_type = std::chrono::seconds;
+
+    static std::string key();
+    static void validate(const std::string&);
+    static void validate(const PluginConfiguration&);
+    static std::string defaultValue();
+    static value_type parse(const std::string&);
+    static details::Access access();
+    static details::Category category();
+};
+
+}  // namespace vpu

inference-engine/src/vpu/common/include/vpu/configuration/options/device_id.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <string>
+
+#include "vpu/configuration/as_parameter_enabler.hpp"
+
+namespace vpu {
+
+namespace details {
+
+enum class Access;
+enum class Category;
+
+}  // namespace details
+
+class PluginConfiguration;
+
+struct DeviceIDOption : public AsParameterEnabler {
+    using value_type = std::string;
+
+    static std::string key();
+    static void validate(const std::string&);
+    static void validate(const PluginConfiguration&);
+    static std::string defaultValue();
+    static value_type parse(const std::string&);
+    static details::Access access();
+    static details::Category category();
+};
+
+}  // namespace vpu

inference-engine/src/vpu/common/include/vpu/configuration/options/disable_convert_stages.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <string>
+
+#include "vpu/configuration/as_parameter_enabler.hpp"
+
+namespace vpu {
+
+namespace details {
+
+enum class Access;
+enum class Category;
+
+}  // namespace details
+
+class PluginConfiguration;
+
+struct DisableConvertStagesOption : public AsParsedParameterEnabler<DisableConvertStagesOption> {
+    using value_type = bool;
+
+    static std::string key();
+    static void validate(const std::string&);
+    static void validate(const PluginConfiguration&);
+    static std::string defaultValue();
+    static value_type parse(const std::string&);
+    static details::Access access();
+    static details::Category category();
+};
+
+}  // namespace vpu

inference-engine/src/vpu/common/include/vpu/configuration/options/disable_reorder.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <string>
+
+#include "vpu/configuration/as_parameter_enabler.hpp"
+
+namespace vpu {
+
+namespace details {
+
+enum class Access;
+enum class Category;
+
+}  // namespace details
+
+class PluginConfiguration;
+
+struct DisableReorderOption : public AsParsedParameterEnabler<DisableReorderOption> {
+    using value_type = bool;
+
+    static std::string key();
+    static void validate(const std::string&);
+    static void validate(const PluginConfiguration&);
+    static std::string defaultValue();
+    static value_type parse(const std::string&);
+    static details::Access access();
+    static details::Category category();
+};
+
+}  // namespace vpu