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

First stage of the AUTO-MULTI merge: redirecting AUTO to the MULTI device plugin (#7037)

Browse Source 
* Redirect -d AUTO to MULTI device plugin

Signed-off-by: Shoujiang Ma <shoujiang.ma@intel.com>

* Modify AUTO tests with MULTI config

Signed-off-by: Shoujiang Ma <shoujiang.ma@intel.com>

* Fix CI

Signed-off-by: Shoujiang Ma <shoujiang.ma@intel.com>

* Fix bug: CVS-62424

Signed-off-by: Shoujiang Ma <shoujiang.ma@intel.com>

* Add some tests for AUTO

Signed-off-by: Shoujiang Ma <shoujiang.ma@intel.com>

* Add select device logic to MULTI

Signed-off-by: Shoujiang Ma <shoujiang.ma@intel.com>

* Fix extract device name bug

Signed-off-by: Shoujiang Ma <shoujiang.ma@intel.com>

* Address reviewer's comment

Signed-off-by: Shoujiang Ma <shoujiang.ma@intel.com>

* Delete AUTO plugin source code

Signed-off-by: Shoujiang Ma <shoujiang.ma@intel.com>
This commit is contained in:
Shoujiang Ma authored and GitHub committed 2021-08-18 13:12:27 +03:00
1 parent 6369f43c99
commit 8968a328d6
38 files changed
+311 -1077
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

inference-engine/samples/benchmark_app/main.cpp
+3
View File
@@ -212,6 +212,9 @@ int main(int argc, char* argv[]) {
bool perf_counts = false;
// Update config per device according to command line parameters
for (auto& device : devices) {
if (device == "AUTO") {
continue;
}
if (!config.count(device))
config[device] = {};
std::map<std::string, std::string>& device_config = config.at(device);
inference-engine/src/auto_plugin/auto_exec_network.cpp
-136
View File
@@ -1,136 +0,0 @@
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <string>
#include <memory>
#include <map>
#include "ie_metric_helpers.hpp"
#include "auto_exec_network.hpp"
#include "auto_infer_request.hpp"
namespace AutoPlugin {
using namespace InferenceEngine;
AutoExecutableNetwork::AutoExecutableNetwork(NetworkFuture cpuFuture,
NetworkFuture acceleratorFuture,
bool enablePerfCount)
: _cpuFuture(std::move(cpuFuture))
, _acceleratorFuture(std::move(acceleratorFuture))
, _enablePerfCount(enablePerfCount) {
// both are valid, like AUTO:CPU,GPU
if (_cpuFuture.valid() && _acceleratorFuture.valid()) {
try {
_networkFirstReady = _cpuFuture.get();
_alreadyActualNetwork = false;
} catch (const std::exception& e) {
printf("Warning: load network to CPU failed: %s\n", e.what());
_networkActualNeeded = _acceleratorFuture.get();
_alreadyActualNetwork = true;
}
} else if (_acceleratorFuture.valid()) { // only accelerator is valid, like AUTO:GPU
_networkActualNeeded = _acceleratorFuture.get();
_alreadyActualNetwork = true;
} else if (_cpuFuture.valid()) { // only CPU is valid, like AUTO:CPU
_networkActualNeeded = _cpuFuture.get();
_alreadyActualNetwork = true;
} else {
IE_THROW() << "No device task available";
}
}
AutoExecutableNetwork::~AutoExecutableNetwork() = default;
InferenceEngine::IInferRequestInternal::Ptr AutoExecutableNetwork::CreateInferRequestImpl(InputsDataMap networkInputs,
OutputsDataMap networkOutputs) {
InferenceEngine::SoExecutableNetworkInternal network;
SoIInferRequestInternal inferRequest;
if (TryGetActualNetwork(network)) {
inferRequest = {_networkActualNeeded, _networkActualNeeded->CreateInferRequest()};
} else {
inferRequest = {_networkFirstReady, _networkFirstReady->CreateInferRequest()};
}
return std::make_shared<AutoInferRequest>(_networkInputs, _networkOutputs, inferRequest,
shared_from_this(), _alreadyActualNetwork,
_enablePerfCount);
}
bool AutoExecutableNetwork::TryGetActualNetwork(InferenceEngine::SoExecutableNetworkInternal& soExecNetwork) {
// try to get actual network
if (_acceleratorFuture.valid() && _acceleratorFuture.wait_for(std::chrono::nanoseconds(0)) == std::future_status::ready) {
soExecNetwork = _acceleratorFuture.get();
_alreadyActualNetwork = true;
_networkActualNeeded = soExecNetwork;
// reapply config to actual network
// fixme: GPU doesn't support SetConfig and throw exception
try {
_networkActualNeeded->SetConfig(_cacheConfig);
} catch (...) {
}
return true;
}
// if already get actual network
if (_alreadyActualNetwork) {
soExecNetwork = _networkActualNeeded;
return true;
}
return false;
}
void AutoExecutableNetwork::WaitForActualDevice() const {
if (_alreadyActualNetwork) {
return;
}
if (_acceleratorFuture.valid()) {
_networkActualNeeded = _acceleratorFuture.get();
_alreadyActualNetwork = true;
} else {
IE_THROW() << "Export failed due to no valid executable network";
}
}
void AutoExecutableNetwork::Export(std::ostream& networkModel) {
//fixme: the Export should work with actual device, so we have to wait!!!
WaitForActualDevice();
_networkActualNeeded->Export(networkModel);
}
RemoteContext::Ptr AutoExecutableNetwork::GetContext() const {
// fixme: the GetContext should work with actual device, so we have to wait!!!
WaitForActualDevice();
return _networkActualNeeded->GetContext();
}
InferenceEngine::CNNNetwork AutoExecutableNetwork::GetExecGraphInfo() {
WaitForActualDevice();
return _networkActualNeeded->GetExecGraphInfo();
}
Parameter AutoExecutableNetwork::GetMetric(const std::string &name) const {
// fixme: should we wait actual device? meanwhile it will block inference, how to fix?
// WaitForActualDevice();
if (_alreadyActualNetwork) {
return _networkActualNeeded->GetMetric(name);
} else {
return _networkFirstReady->GetMetric(name);
}
}
void AutoExecutableNetwork::SetConfig(const std::map<std::string, Parameter>& config) {
//fixme: have to store the config and reapply when the networks swapped
_cacheConfig = config;
if (_alreadyActualNetwork) {
_networkActualNeeded->SetConfig(config);
} else {
_networkFirstReady->SetConfig(config);
}
}
Parameter AutoExecutableNetwork::GetConfig(const std::string& name) const {
//fixme: carefuly select between FirstLoaded and ActuallyNeeded
return _cacheConfig;
}
} // namespace AutoPlugin
inference-engine/src/auto_plugin/auto_exec_network.hpp
-56
View File
@@ -1,56 +0,0 @@
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <atomic>
#include <mutex>
#include <queue>
#include <unordered_map>
#include <map>
#include <vector>
#include <string>
#include <cpp_interfaces/impl/ie_executable_network_thread_safe_default.hpp>
#include <threading/ie_itask_executor.hpp>
namespace AutoPlugin {
using DeviceName = std::string;
using NetworkFuture = std::future<InferenceEngine::SoExecutableNetworkInternal>;
class AutoExecutableNetwork : public InferenceEngine::IExecutableNetworkInternal {
public:
using Ptr = std::shared_ptr<AutoExecutableNetwork>;
explicit AutoExecutableNetwork(NetworkFuture cpuTask,
NetworkFuture acceleratorTask,
bool enablePerfCount);
void Export(std::ostream& networkModel) override;
InferenceEngine::RemoteContext::Ptr GetContext() const override;
InferenceEngine::CNNNetwork GetExecGraphInfo() override;
InferenceEngine::Parameter GetMetric(const std::string &name) const override;
void SetConfig(const std::map<std::string, InferenceEngine::Parameter>& config) override;
InferenceEngine::Parameter GetConfig(const std::string& name) const override;
InferenceEngine::IInferRequestInternal::Ptr CreateInferRequestImpl(InferenceEngine::InputsDataMap networkInputs,
InferenceEngine::OutputsDataMap networkOutputs) override;
bool TryGetActualNetwork(InferenceEngine::SoExecutableNetworkInternal& soExecNetwork);
~AutoExecutableNetwork();
private:
void WaitForActualDevice() const;
private:
InferenceEngine::SoExecutableNetworkInternal _networkFirstReady;
mutable InferenceEngine::SoExecutableNetworkInternal _networkActualNeeded;
NetworkFuture _cpuFuture;
mutable NetworkFuture _acceleratorFuture;
bool _enablePerfCount;
mutable std::atomic<bool> _alreadyActualNetwork = {false};
std::map<std::string, InferenceEngine::Parameter> _cacheConfig;
};
} // namespace AutoPlugin
inference-engine/src/auto_plugin/auto_infer_request.cpp
-103
View File
@@ -1,103 +0,0 @@
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <iostream>
#include "auto_infer_request.hpp"
#include <ie_input_info.hpp>
#include <cpp_interfaces/interface/ie_iinfer_request_internal.hpp>
namespace AutoPlugin {
using namespace InferenceEngine;
AutoInferRequest::AutoInferRequest(const InputsDataMap& networkInputs,
const OutputsDataMap& networkOutputs,
const SoIInferRequestInternal& inferRequest,
const InferenceEngine::IExecutableNetworkInternal::Ptr autoExecutableNetwork,
bool alreadyActualNetwork,
bool enablePerfCount)
: IInferRequestInternal(networkInputs, networkOutputs)
, _inferRequest(inferRequest)
, _autoExecutableNetwork(std::dynamic_pointer_cast<AutoPlugin::AutoExecutableNetwork>(autoExecutableNetwork))
, _alreadyActualNetwork(alreadyActualNetwork)
, _enablePerfCount(enablePerfCount) {
IE_ASSERT(_autoExecutableNetwork != nullptr);
for (const auto &it : _networkInputs)
_inputs[it.first] = _inferRequest->GetBlob(it.first);
for (const auto &it : _networkOutputs)
_outputs[it.first] = _inferRequest->GetBlob(it.first);
}
std::map<std::string, InferenceEngine::InferenceEngineProfileInfo> AutoInferRequest::GetPerformanceCounts() const {
if (_enablePerfCount) {
try {
return _inferRequest->GetPerformanceCounts();
} catch (...) {
return {};
}
} else {
return {};
}
}
void AutoInferRequest::InferImpl() {
HotSwapRequests(); //safe to call here (before actual inference started)
SetBlobsToDeviceRequest();
_inferRequest->Infer();
}
void AutoInferRequest::SetBlob(const std::string& name, const InferenceEngine::Blob::Ptr& data) {
IInferRequestInternal::SetBlob(name, data);
}
Blob::Ptr AutoInferRequest::GetBlob(const std::string& name) {
return IInferRequestInternal::GetBlob(name);
}
void AutoInferRequest::Cancel() {
_inferRequest->Cancel();
}
void AutoInferRequest::StartAsync() {
HotSwapRequests(); //safe to call here (before actual inference started)
SetBlobsToDeviceRequest();
_inferRequest->StartAsync();
}
InferenceEngine::StatusCode AutoInferRequest::Wait(int64_t millis_timeout) {
return _inferRequest->Wait(millis_timeout);
}
void AutoInferRequest::SetCallback(Callback callback) {
_callback = callback;
_inferRequest->SetCallback(callback);
}
void AutoInferRequest::HotSwapRequests() {
if (!_alreadyActualNetwork) {
InferenceEngine::SoExecutableNetworkInternal tempSoExecNetwork;
if (_autoExecutableNetwork->TryGetActualNetwork(tempSoExecNetwork)) {
_alreadyActualNetwork = true;
_inferRequest = {tempSoExecNetwork, tempSoExecNetwork->CreateInferRequest()};
_inferRequest->SetCallback(_callback);
}
}
}
void AutoInferRequest::SetBlobsToDeviceRequest() {
for (const auto &it : _networkInputs) {
const auto &name = it.first;
// this assumes the request is already in BUSY state
auto blob = GetBlob(name);
if (_inferRequest->GetBlob(name) != blob)
_inferRequest->SetBlob(name, blob);
}
for (const auto &it : _networkOutputs) {
const auto &name = it.first;
// this assumes the request is already in BUSY state
auto blob = GetBlob(name);
if (_inferRequest->GetBlob(name) != blob)
_inferRequest->SetBlob(name, blob);
}
}
} // namespace AutoPlugin
inference-engine/src/auto_plugin/auto_infer_request.hpp
-55
View File
@@ -1,55 +0,0 @@
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <atomic>
#include <cpp_interfaces/interface/ie_iinfer_request_internal.hpp>
#include <ie_blob.h>
#include <ie_common.h>
#include <map>
#include <memory>
#include <mutex>
#include <queue>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include "auto_exec_network.hpp"
namespace AutoPlugin {
class AutoInferRequest : public InferenceEngine::IInferRequestInternal {
public:
using Ptr = std::shared_ptr<AutoInferRequest>;
explicit AutoInferRequest(const InferenceEngine::InputsDataMap& networkInputs,
const InferenceEngine::OutputsDataMap& networkOutputs,
const InferenceEngine::SoIInferRequestInternal& inferRequest,
const InferenceEngine::IExecutableNetworkInternal::Ptr executeNetwork,
bool alreadyActualNetwork,
bool enablePerfCount);
std::map<std::string, InferenceEngine::InferenceEngineProfileInfo> GetPerformanceCounts() const override;
void InferImpl() override;
void SetBlob(const std::string& name, const InferenceEngine::Blob::Ptr& data) override;
InferenceEngine::Blob::Ptr GetBlob(const std::string& name) override;
void Cancel() override;
//async impl
void StartAsync() override;
InferenceEngine::StatusCode Wait(int64_t millis_timeout) override;
void SetCallback(Callback callback) override;
private:
void HotSwapRequests();
void SetBlobsToDeviceRequest();
private:
InferenceEngine::SoIInferRequestInternal _inferRequest;
AutoPlugin::AutoExecutableNetwork::Ptr _autoExecutableNetwork;
Callback _callback; // need to save the callback for hot-swap of the requests
bool _alreadyActualNetwork{ false };
bool _enablePerfCount { false };
};
} // namespace AutoPlugin
inference-engine/src/auto_plugin/auto_plugin.cpp
+1 -388
View File
@@ -2,397 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <string>
#include <vector>
#include <memory>
#include <map>
#include <unordered_set>
#include <ie_metric_helpers.hpp>
#include <threading/ie_executor_manager.hpp>
#include <ie_algorithm.hpp>
#include <ngraph/opsets/opset1.hpp>
#include <transformations/utils/utils.hpp>
#include <ie_icore.hpp>
#include "auto_plugin.hpp"
#include "ngraph_ops/convolution_ie.hpp"
#include "ngraph_ops/deconvolution_ie.hpp"
namespace AutoPlugin {
namespace {
std::string GetNetworkPrecision(const InferenceEngine::CNNNetwork &network) {
auto nGraphFunc = network.getFunction();
bool isINTModel = ngraph::op::util::has_op_with_type<ngraph::op::FakeQuantize>(nGraphFunc);
if (isINTModel) {
return METRIC_VALUE(INT8);
}
for (auto & node : nGraphFunc->get_ordered_ops()) {
if (std::dynamic_pointer_cast<ngraph::opset1::Convolution>(node) ||
std::dynamic_pointer_cast<ngraph::opset1::GroupConvolution>(node) ||
std::dynamic_pointer_cast<ngraph::opset1::GroupConvolutionBackpropData>(node) ||
std::dynamic_pointer_cast<ngraph::opset1::ConvolutionBackpropData>(node) ||
std::dynamic_pointer_cast<ngraph::op::ConvolutionIE>(node) ||
std::dynamic_pointer_cast<ngraph::op::DeconvolutionIE>(node)) {
auto layerType = node->input(1).get_element_type().get_type_name();
if (layerType == "f32")
return METRIC_VALUE(FP32);
if (layerType == "f16")
return METRIC_VALUE(FP16);
}
}
return METRIC_VALUE(FP32);
}
} // namespace
AutoInferencePlugin::AutoInferencePlugin() {
_pluginName = "AUTO";
}
IE::IExecutableNetworkInternal::Ptr AutoInferencePlugin::LoadNetwork(const std::string& fileName,
const ConfigType& config) {
return LoadNetworkImpl(fileName, {}, config);
}
IE::IExecutableNetworkInternal::Ptr AutoInferencePlugin::LoadExeNetworkImpl(const IE::CNNNetwork& network,
const ConfigType& config) {
if (network.getFunction() == nullptr) {
IE_THROW() << "AUTO device supports just ngraph network representation";
}
auto networkPrecision = GetNetworkPrecision(network);
return LoadNetworkImpl({}, network, config, networkPrecision);
}
std::shared_ptr<AutoExecutableNetwork> AutoInferencePlugin::LoadNetworkImpl(const std::string& modelPath,
const InferenceEngine::CNNNetwork& network,
const ConfigType& config,
const std::string& networkPrecision) {
if (GetCore() == nullptr) {
IE_THROW() << "Please, work with AUTO device via InferencEngine::Core object";
}
if (modelPath.empty() && network.getFunction() == nullptr) {
IE_THROW() << "AUTO device supports just ngraph network representation";
}
auto fullConfig = mergeConfigs(_config, config);
CheckConfig(fullConfig);
auto metaDevices = GetDeviceList(fullConfig);
auto core = GetCore(); // shared_ptr that holds the Core while the lambda below (which captures that by val) works
auto LoadNetworkAsync =
[core, modelPath, network](const std::string& device)
-> IE::SoExecutableNetworkInternal {
IE::SoExecutableNetworkInternal executableNetwork;
if (!modelPath.empty()) {
executableNetwork = core->LoadNetwork(modelPath, device, {});
} else {
executableNetwork = core->LoadNetwork(network, device, {});
}
return executableNetwork;
};
NetworkFuture cpuFuture;
NetworkFuture acceleratorFuture;
// start CPU task
const auto CPUIter = std::find_if(metaDevices.begin(), metaDevices.end(),
[=](const std::string& d)->bool{return d.find("CPU") != std::string::npos;});
if (CPUIter != metaDevices.end()) {
cpuFuture = std::async(std::launch::async, LoadNetworkAsync, *CPUIter);
}
// start accelerator task, like GPU
const auto accelerator = SelectDevice(metaDevices, networkPrecision);
bool isAccelerator = accelerator.find("CPU") == std::string::npos;
if (isAccelerator) {
acceleratorFuture = std::async(std::launch::async, LoadNetworkAsync, accelerator);
}
bool enablePerfCount = fullConfig.find(IE::PluginConfigParams::KEY_PERF_COUNT) != fullConfig.end();
return std::make_shared<AutoExecutableNetwork>(std::move(cpuFuture), std::move(acceleratorFuture), enablePerfCount);
}
IE::QueryNetworkResult AutoInferencePlugin::QueryNetwork(const IE::CNNNetwork& network, const ConfigType& config) const {
IE::QueryNetworkResult queryResult = {};
if (GetCore() == nullptr) {
IE_THROW() << "Please, work with AUTO device via InferencEngine::Core object";
}
if (network.getFunction() == nullptr) {
IE_THROW() << "AUTO device supports just ngraph network representation";
}
auto fullConfig = mergeConfigs(_config, config);
auto metaDevices = GetDeviceList(fullConfig);
std::unordered_set<std::string> supportedLayers;
for (auto&& value : metaDevices) {
try {
auto deviceQr = GetCore()->QueryNetwork(network, value, {});
std::unordered_set<std::string> deviceSupportedLayers;
for (auto &&layerQr : deviceQr.supportedLayersMap) {
deviceSupportedLayers.emplace(layerQr.first);
}
supportedLayers = supportedLayers.empty()
? deviceSupportedLayers : (deviceSupportedLayers.empty()
? supportedLayers : IE::details::Intersection(
supportedLayers, deviceSupportedLayers));
break;
} catch (...) {
}
}
for (auto&& supportedLayer : supportedLayers) {
queryResult.supportedLayersMap[supportedLayer] = GetName();
}
return queryResult;
}
IE::Parameter AutoInferencePlugin::GetConfig(const std::string& name,
const std::map<std::string, IE::Parameter> & options) const {
auto it = _config.find(name);
if (it == _config.end()) {
IE_THROW() << "Unsupported config key: " << name;
} else {
return { it->second };
}
}
void AutoInferencePlugin::SetConfig(const ConfigType& config) {
for (auto && kvp : config) {
if (kvp.first.find("AUTO_") == 0) {
_config[kvp.first] = kvp.second;
} else if (kvp.first == IE::PluginConfigParams::KEY_PERF_COUNT) {
if (kvp.second == IE::PluginConfigParams::YES ||
kvp.second == IE::PluginConfigParams::NO) {
_config[kvp.first] = kvp.second;
} else {
IE_THROW() << "Unsupported config value: " << kvp.second
<< " for key: " << kvp.first;
}
} else {
IE_THROW() << "Unsupported config key: " << kvp.first;
}
}
}
IE::Parameter AutoInferencePlugin::GetMetric(const std::string& name,
const std::map<std::string, IE::Parameter> & options) const {
if (name == METRIC_KEY(SUPPORTED_METRICS)) {
std::vector<std::string> metrics;
metrics.emplace_back(METRIC_KEY(SUPPORTED_METRICS));
metrics.emplace_back(METRIC_KEY(FULL_DEVICE_NAME));
metrics.emplace_back(METRIC_KEY(SUPPORTED_CONFIG_KEYS));
metrics.emplace_back(METRIC_KEY(OPTIMIZATION_CAPABILITIES));
IE_SET_METRIC_RETURN(SUPPORTED_METRICS, metrics);
} else if (name == METRIC_KEY(FULL_DEVICE_NAME)) {
std::string device_name = {"Inference Engine AUTO device"};
IE_SET_METRIC_RETURN(FULL_DEVICE_NAME, device_name);
} else if (name == METRIC_KEY(SUPPORTED_CONFIG_KEYS)) {
std::vector<std::string> configKeys = {
IE::KEY_AUTO_DEVICE_LIST,
IE::PluginConfigParams::KEY_PERF_COUNT
};
IE_SET_METRIC_RETURN(SUPPORTED_CONFIG_KEYS, configKeys);
} else if (name == METRIC_KEY(OPTIMIZATION_CAPABILITIES)) {
std::vector<std::string> capabilities = GetOptimizationCapabilities(options);
IE_SET_METRIC_RETURN(OPTIMIZATION_CAPABILITIES, capabilities);
} else {
IE_THROW() << "Unsupported metric key " << name;
}
}
//////////////////////////////////// private & protected functions ///////////////////
std::vector<DeviceName> AutoInferencePlugin::GetDeviceList(const ConfigType& config) const {
std::vector<DeviceName> deviceList;
auto deviceListConfig = config.find(IE::KEY_AUTO_DEVICE_LIST);
if (deviceListConfig == config.end()) {
deviceList = GetCore()->GetAvailableDevices();
} else {
deviceList = IE::DeviceIDParser::getHeteroDevices(deviceListConfig->second);
}
if (deviceList.empty()) {
IE_THROW() << "Please, check environment due to no supported devices can be used";
}
return deviceList;
}
std::vector<std::string> AutoInferencePlugin::GetOptimizationCapabilities(const std::map<std::string, IE::Parameter> & options) const {
// FIXME: workaround to get devicelist.
std::unordered_set<std::string> capabilities;
std::vector<std::string> queryDeviceLists{"CPU", "GPU"};
if (options.find(IE::KEY_AUTO_DEVICE_LIST) != options.end()) {
auto deviceListConfig = options.at(IE::KEY_AUTO_DEVICE_LIST).as<std::string>();
queryDeviceLists = IE::DeviceIDParser::getHeteroDevices(deviceListConfig);
} else if (_config.find(IE::KEY_AUTO_DEVICE_LIST) != _config.end()) {
auto deviceListConfig = _config.at(IE::KEY_AUTO_DEVICE_LIST);
queryDeviceLists = IE::DeviceIDParser::getHeteroDevices(deviceListConfig);
}
for (auto &item : queryDeviceLists) {
try {
std::vector<std::string> device_cap =
GetCore()->GetMetric(item, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
for (auto &cap : device_cap) {
capabilities.insert(cap);
}
} catch (...) {
}
}
return {capabilities.begin(), capabilities.end()};
}
void AutoInferencePlugin::CheckConfig(const ConfigType& config) {
std::vector<std::string> supportedConfigKeys = GetMetric(METRIC_KEY(SUPPORTED_CONFIG_KEYS), {});
for (auto&& kvp : config) {
if (kvp.first.find("AUTO_") == 0) {
continue;
} else if (kvp.first == IE::PluginConfigParams::KEY_PERF_COUNT) {
if (kvp.second == IE::PluginConfigParams::YES ||
kvp.second == IE::PluginConfigParams::NO) {
continue;
} else {
IE_THROW() << "Unsupported config value: " << kvp.second
<< " for key: " << kvp.first;
}
} else {
IE_THROW() << "Unsupported config key: " << kvp.first;
}
}
}
DeviceName AutoInferencePlugin::SelectDevice(const std::vector<DeviceName>& metaDevices, const std::string& networkPrecision) {
if (metaDevices.empty()) {
IE_THROW(NotFound) << "No available device to select in AUTO plugin";
}
if (metaDevices.size() == 1) {
return metaDevices.at(0);
}
std::vector<DeviceName> CPU;
std::vector<DeviceName> dGPU;
std::vector<DeviceName> iGPU;
std::vector<DeviceName> MYRIAD;
std::vector<DeviceName> VPUX;
for (auto& item : metaDevices) {
if (item.find("CPU") == 0) {
CPU.push_back(item);
continue;
}
if (item.find("MYRIAD") == 0) {
MYRIAD.push_back(item);
continue;
}
if (item.find("VPUX") == 0) {
VPUX.push_back(item);
continue;
}
if (item.find("GPU") == 0) {
auto gpuFullDeviceName = GetCore()->GetMetric(item, METRIC_KEY(FULL_DEVICE_NAME)).as<std::string>();
if (gpuFullDeviceName.find("iGPU") != std::string::npos) {
iGPU.push_back(item);
} else if (gpuFullDeviceName.find("dGPU") != std::string::npos) {
dGPU.push_back(item);
}
continue;
}
}
if (CPU.empty() && dGPU.empty() && iGPU.empty() && MYRIAD.empty() && VPUX.empty()) {
IE_THROW(NotFound) << "No available device found";
}
// Priority of selecting device: dGPU > VPUX > iGPU > MYRIAD > CPU
if (!dGPU.empty()) {
for (auto&& item : dGPU) {
std::vector<std::string> capability = GetCore()->GetMetric(item, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), networkPrecision);
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!VPUX.empty()) {
for (auto&& item : VPUX) {
std::vector<std::string> capability = GetCore()->GetMetric(item, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), networkPrecision);
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!iGPU.empty()) {
for (auto&& item : iGPU) {
std::vector<std::string> capability = GetCore()->GetMetric(item, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), networkPrecision);
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!MYRIAD.empty()) {
for (auto&& item : MYRIAD) {
std::vector<std::string> capability = GetCore()->GetMetric(item, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), networkPrecision);
if (supportNetwork != capability.end()) {
return item;
}
}
}
// If network is FP32 but there is no device support FP32, offload FP32 network to device support FP16.
if (networkPrecision == "FP32") {
if (!dGPU.empty()) {
for (auto&& item : dGPU) {
std::vector<std::string> capability = GetCore()->GetMetric(item, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), "FP16");
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!VPUX.empty()) {
for (auto&& item : VPUX) {
std::vector<std::string> capability = GetCore()->GetMetric(item, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), "FP16");
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!iGPU.empty()) {
for (auto&& item : iGPU) {
std::vector<std::string> capability = GetCore()->GetMetric(item, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), "FP16");
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!MYRIAD.empty()) {
for (auto&& item : MYRIAD) {
std::vector<std::string> capability = GetCore()->GetMetric(item, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), "FP16");
if (supportNetwork != capability.end()) {
return item;
}
}
}
}
if (CPU.empty()) {
IE_THROW() << "Cannot select any device";
}
return CPU[0];
}
ConfigType AutoInferencePlugin::mergeConfigs(ConfigType config, const ConfigType& local) {
for (auto && kvp : local) {
config[kvp.first] = kvp.second;
}
return config;
}
// define CreatePluginEngine to create plugin instance
static const IE::Version version = {{2, 1}, CI_BUILD_NUMBER, "AutoPlugin"};
static const InferenceEngine::Version version = {{2, 1}, CI_BUILD_NUMBER, "AutoPlugin"};
IE_DEFINE_PLUGIN_CREATE_FUNCTION(AutoInferencePlugin, version)
} // namespace AutoPlugin
inference-engine/src/auto_plugin/auto_plugin.hpp
+2 -31
View File
@@ -4,43 +4,14 @@
#pragma once
#include <map>
#include <vector>
#include <string>
#include <unordered_set>
#include <type_traits>
#include <cpp_interfaces/interface/ie_internal_plugin_config.hpp>
#include <cpp_interfaces/interface/ie_iplugin_internal.hpp>
#include <threading/ie_executor_manager.hpp>
#include "auto_exec_network.hpp"
namespace AutoPlugin {
namespace IE = InferenceEngine;
using ConfigType = std::map<std::string, std::string>;
class AutoInferencePlugin : public IE::IInferencePlugin {
class AutoInferencePlugin : public InferenceEngine::IInferencePlugin {
public:
AutoInferencePlugin();
AutoInferencePlugin() = default;
~AutoInferencePlugin() = default;
IE::IExecutableNetworkInternal::Ptr LoadExeNetworkImpl(const IE::CNNNetwork& network, const ConfigType& config) override;
IE::IExecutableNetworkInternal::Ptr LoadNetwork(const std::string& fileName, const ConfigType& config) override;
IE::QueryNetworkResult QueryNetwork(const IE::CNNNetwork& network, const ConfigType& config) const override;
IE::Parameter GetMetric(const std::string& name, const std::map<std::string, IE::Parameter>& options) const override;
IE::Parameter GetConfig(const std::string& name, const std::map<std::string, IE::Parameter> & options) const override;
void SetConfig(const ConfigType& config) override;
private:
std::shared_ptr<AutoExecutableNetwork> LoadNetworkImpl(const std::string& modelPath,
const InferenceEngine::CNNNetwork& network,
const ConfigType &config,
const std::string &networkPrecision = METRIC_VALUE(FP32));
std::vector<DeviceName> GetDeviceList(const ConfigType& config) const;
std::vector<std::string> GetOptimizationCapabilities(const std::map<std::string, IE::Parameter>& options) const;
DeviceName SelectDevice(const std::vector<DeviceName>& metaDevices, const std::string& networkPrecision = METRIC_VALUE(FP32));
void CheckConfig(const ConfigType& config);
static ConfigType mergeConfigs(ConfigType config, const ConfigType& local);
};
} // namespace AutoPlugin
inference-engine/src/inference_engine/src/ie_core.cpp
+31 -15
View File
@@ -62,18 +62,17 @@ Parsed<T> parseDeviceNameIntoConfig(const std::string& deviceName, const std::ma
} else if (deviceName_.find("MULTI:") == 0) {
deviceName_ = "MULTI";
config_[InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES] = deviceName.substr(6);
} else if (deviceName_.find("AUTO") == 0) {
deviceName_ = "AUTO";
if (deviceName.size() > std::string("AUTO").size()) {
std::string deviceList = deviceName.substr(std::string("AUTO:").size());
if (deviceList.find("AUTO") != std::string::npos) {
IE_THROW() << "Device list for AUTO should not be AUTO";
}
config_[InferenceEngine::KEY_AUTO_DEVICE_LIST] = deviceName.substr(std::string("AUTO:").size());
} else if (deviceName.find("AUTO") == 0) {
deviceName_ = "MULTI";
if (deviceName.find("AUTO:") == 0) {
config_[InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES] =
deviceName.substr(std::string("AUTO:").size());
}
config_.insert({CONFIG_KEY_INTERNAL(WORK_MODE), ""});
} else {
if (deviceName_.empty()) {
deviceName_ = "AUTO";
if (deviceName_ == "AUTO") {
deviceName_ = "MULTI";
config_.insert({CONFIG_KEY_INTERNAL(WORK_MODE), ""});
}
InferenceEngine::DeviceIDParser parser(deviceName_);
deviceName_ = parser.getDeviceName();
@@ -579,7 +578,21 @@ public:
}
}
auto parsed = parseDeviceNameIntoConfig(deviceName);
// AUTO case
{
if (deviceName.find("AUTO:") == 0) {
IE_THROW()
<< "You can get specific metrics with the GetMetric only for the MULTI itself (without devices). "
"To get individual devices's metrics call GetMetric for each device separately";
}
}
std::string pluginName = deviceName;
if (pluginName == "AUTO") {
pluginName = "MULTI";
}
auto parsed = parseDeviceNameIntoConfig(pluginName);
// we need to return a copy of Parameter object which is created on Core side,
// not in InferenceEngine plugin side, which can be unloaded from Core in a parallel thread
@@ -629,11 +642,14 @@ public:
* @param deviceName A name of device
* @return Reference to a CPP plugin wrapper
*/
InferenceEngine::InferencePlugin GetCPPPluginByName(const std::string& deviceName) const {
InferenceEngine::InferencePlugin GetCPPPluginByName(const std::string& pluginName) const {
OV_ITT_SCOPE(FIRST_INFERENCE, InferenceEngine::itt::domains::IE_LT, "CoreImpl::GetCPPPluginByName");
std::lock_guard<std::mutex> lock(pluginsMutex);
auto deviceName = pluginName;
if (deviceName == "AUTO") {
deviceName = "MULTI";
}
auto it = pluginRegistry.find(deviceName);
if (it == pluginRegistry.end()) {
IE_THROW() << "Device with \"" << deviceName << "\" name is not registered in the InferenceEngine";
@@ -856,9 +872,9 @@ public:
} else if (deviceName.find("AUTO") == 0) {
auto pos = deviceName.find_first_of(":");
if (pos != std::string::npos) {
deviceNames = InferenceEngine::DeviceIDParser::getHeteroDevices(deviceName.substr(pos + 1));
deviceNames = InferenceEngine::DeviceIDParser::getMultiDevices(deviceName.substr(pos + 1));
}
deviceNames.emplace_back("AUTO");
deviceNames.emplace_back("MULTI");
} else {
deviceNames.push_back(deviceName);
}
inference-engine/src/multi_device/CMakeLists.txt
+1 -1
View File
@@ -12,7 +12,7 @@ ie_add_plugin(NAME ${TARGET_NAME}
SOURCES ${SOURCES} ${HEADERS}
VERSION_DEFINES_FOR multi_device_plugin.cpp)
target_link_libraries(${TARGET_NAME} PRIVATE inference_engine)
target_link_libraries(${TARGET_NAME} PRIVATE inference_engine ngraph inference_engine_transformations)
set_ie_threading_interface_for(${TARGET_NAME})
inference-engine/src/multi_device/multi_device_plugin.cpp
+196 -15
View File
@@ -10,6 +10,10 @@
#include <unordered_map>
#include <unordered_set>
#include <ngraph/opsets/opset1.hpp>
#include <transformations/utils/utils.hpp>
#include "ngraph_ops/convolution_ie.hpp"
#include "ngraph_ops/deconvolution_ie.hpp"
#include <ie_metric_helpers.hpp>
#include <threading/ie_executor_manager.hpp>
@@ -21,6 +25,30 @@
namespace MultiDevicePlugin {
using namespace InferenceEngine;
namespace {
std::string GetNetworkPrecision(const InferenceEngine::CNNNetwork &network) {
auto nGraphFunc = network.getFunction();
bool isINTModel = ngraph::op::util::has_op_with_type<ngraph::op::FakeQuantize>(nGraphFunc);
if (isINTModel) {
return METRIC_VALUE(INT8);
}
for (auto & node : nGraphFunc->get_ordered_ops()) {
if (std::dynamic_pointer_cast<ngraph::opset1::Convolution>(node) ||
std::dynamic_pointer_cast<ngraph::opset1::GroupConvolution>(node) ||
std::dynamic_pointer_cast<ngraph::opset1::GroupConvolutionBackpropData>(node) ||
std::dynamic_pointer_cast<ngraph::opset1::ConvolutionBackpropData>(node) ||
std::dynamic_pointer_cast<ngraph::op::ConvolutionIE>(node) ||
std::dynamic_pointer_cast<ngraph::op::DeconvolutionIE>(node)) {
auto layerType = node->input(1).get_element_type().get_type_name();
if (layerType == "f32")
return METRIC_VALUE(FP32);
if (layerType == "f16")
return METRIC_VALUE(FP16);
}
}
return METRIC_VALUE(FP32);
}
std::map<std::string, std::string> mergeConfigs(std::map<std::string, std::string> config,
const std::map<std::string, std::string> & local) {
for (auto && kvp : local) {
@@ -28,7 +56,10 @@ namespace {
}
return config;
}
std::vector<std::string> supported_configKeys = {MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES};
std::vector<std::string> supported_configKeys = {
MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES,
CONFIG_KEY_INTERNAL(WORK_MODE)
};
} // namespace
std::map<std::string, std::string> MultiDeviceInferencePlugin::GetSupportedConfig(
@@ -98,8 +129,8 @@ std::vector<DeviceInformation> MultiDeviceInferencePlugin::ParseMetaDevices(cons
InferenceEngine::Parameter MultiDeviceInferencePlugin::GetConfig(const std::string& name,
const std::map<std::string, InferenceEngine::Parameter> & options) const {
if (name == MULTI_CONFIG_KEY(DEVICE_PRIORITIES)) {
auto it = _config.find(MULTI_CONFIG_KEY(DEVICE_PRIORITIES));
if (supported_configKeys.end() != std::find(supported_configKeys.begin(), supported_configKeys.end(), name)) {
auto it = _config.find(name);
if (it == _config.end()) {
IE_THROW() << "Value for KEY_MULTI_DEVICE_PRIORITIES is not set";
} else {
@@ -148,17 +179,23 @@ InferenceEngine::Parameter MultiDeviceInferencePlugin::GetMetric(const std::stri
// Is called only when caching is enabled
IExecutableNetworkInternal::Ptr MultiDeviceInferencePlugin::LoadNetwork(const std::string& modelPath,
const std::map<std::string, std::string>& config) {
return LoadExeNetworkImpl(modelPath, {}, config);
return LoadNetworkImpl(modelPath, {}, config);
}
IExecutableNetworkInternal::Ptr MultiDeviceInferencePlugin::LoadExeNetworkImpl(const CNNNetwork &network,
const std::map<std::string, std::string>& config) {
return LoadExeNetworkImpl({}, network, config);
if (network.getFunction() == nullptr) {
IE_THROW() << "MULTI device supports just ngraph network representation";
}
auto networkPrecision = GetNetworkPrecision(network);
return LoadNetworkImpl({}, network, config, networkPrecision);
}
IExecutableNetworkInternal::Ptr MultiDeviceInferencePlugin::LoadExeNetworkImpl(const std::string& modelPath,
IExecutableNetworkInternal::Ptr MultiDeviceInferencePlugin::LoadNetworkImpl(const std::string& modelPath,
CNNNetwork network,
const std::map<std::string, std::string>& config) {
const std::map<std::string, std::string>& config,
const std::string &networkPrecision) {
if (GetCore() == nullptr) {
IE_THROW() << "Please, work with MULTI device via InferenceEngine::Core object";
}
@@ -168,16 +205,39 @@ IExecutableNetworkInternal::Ptr MultiDeviceInferencePlugin::LoadExeNetworkImpl(c
}
auto fullConfig = mergeConfigs(_config, config);
auto priorities = fullConfig.find(MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES);
if (priorities == fullConfig.end()) {
IE_THROW() << "KEY_MULTI_DEVICE_PRIORITIES key is not set for MULTI device";
}
auto metaDevices = ParseMetaDevices(priorities->second, fullConfig);
// collect the settings that are applicable to the devices we are loading the network to
std::unordered_map<std::string, InferenceEngine::Parameter> multiNetworkConfig;
multiNetworkConfig.insert(*priorities);
std::vector<DeviceInformation> metaDevices;
auto workMode = fullConfig.find(CONFIG_KEY_INTERNAL(WORK_MODE));
auto priorities = fullConfig.find(MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES);
// not found device priorities for -d AUTO use case
if (priorities == fullConfig.end()) {
if (workMode != fullConfig.end()) {
std::string allDevices;
auto availableDevices = GetCore()->GetAvailableDevices();
if (availableDevices.empty()) {
IE_THROW(NotFound) << "No available device found";
}
for (auto&& device : availableDevices) {
allDevices += device;
allDevices += ((device == availableDevices[availableDevices.size()-1]) ? "" : ",");
}
metaDevices = ParseMetaDevices(allDevices, fullConfig);
multiNetworkConfig.insert({MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, allDevices});
} else {
IE_THROW() << "KEY_MULTI_DEVICE_PRIORITIES key is not set for MULTI device";
}
} else { // for use case -d MULTI:xPU or -d AUTO:xPU
metaDevices = ParseMetaDevices(priorities->second, fullConfig);
multiNetworkConfig.insert(*priorities);
}
// check if it is -d AUTO or -d AUTO:xPU use case
if (workMode != fullConfig.end()) {
auto targetDevice = SelectDevice(metaDevices, networkPrecision);
// std::cout << "!!! DEBUG: select device is " << targetDevice.deviceName << std::endl;
metaDevices = { targetDevice };
}
DeviceMap<SoExecutableNetworkInternal> executableNetworkPerDevice;
std::mutex load_mutex;
@@ -275,4 +335,125 @@ QueryNetworkResult MultiDeviceInferencePlugin::QueryNetwork(const CNNNetwork&
return queryResult;
}
DeviceInformation MultiDeviceInferencePlugin::SelectDevice(const std::vector<DeviceInformation>& metaDevices, const std::string& networkPrecision) {
if (metaDevices.empty()) {
IE_THROW(NotFound) << "No available device to select in AUTO plugin";
}
if (metaDevices.size() == 1) {
return metaDevices.at(0);
}
std::vector<DeviceInformation> CPU;
std::vector<DeviceInformation> dGPU;
std::vector<DeviceInformation> iGPU;
std::vector<DeviceInformation> MYRIAD;
std::vector<DeviceInformation> VPUX;
for (auto& item : metaDevices) {
if (item.deviceName.find("CPU") == 0) {
CPU.push_back(item);
continue;
}
if (item.deviceName.find("MYRIAD") == 0) {
MYRIAD.push_back(item);
continue;
}
if (item.deviceName.find("VPUX") == 0) {
VPUX.push_back(item);
continue;
}
if (item.deviceName.find("GPU") == 0) {
auto gpuFullDeviceName = GetCore()->GetMetric(item.deviceName, METRIC_KEY(FULL_DEVICE_NAME)).as<std::string>();
if (gpuFullDeviceName.find("iGPU") != std::string::npos) {
iGPU.push_back(item);
} else if (gpuFullDeviceName.find("dGPU") != std::string::npos) {
dGPU.push_back(item);
}
continue;
}
}
if (CPU.empty() && dGPU.empty() && iGPU.empty() && MYRIAD.empty() && VPUX.empty()) {
IE_THROW(NotFound) << "No available device found";
}
// Priority of selecting device: dGPU > VPUX > iGPU > MYRIAD > CPU
if (!dGPU.empty()) {
for (auto&& item : dGPU) {
std::vector<std::string> capability = GetCore()->GetMetric(item.deviceName, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), networkPrecision);
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!VPUX.empty()) {
for (auto&& item : VPUX) {
std::vector<std::string> capability = GetCore()->GetMetric(item.deviceName, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), networkPrecision);
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!iGPU.empty()) {
for (auto&& item : iGPU) {
std::vector<std::string> capability = GetCore()->GetMetric(item.deviceName, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), networkPrecision);
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!MYRIAD.empty()) {
for (auto&& item : MYRIAD) {
std::vector<std::string> capability = GetCore()->GetMetric(item.deviceName, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), networkPrecision);
if (supportNetwork != capability.end()) {
return item;
}
}
}
// If network is FP32 but there is no device support FP32, offload FP32 network to device support FP16.
if (networkPrecision == "FP32") {
if (!dGPU.empty()) {
for (auto&& item : dGPU) {
std::vector<std::string> capability = GetCore()->GetMetric(item.deviceName, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), "FP16");
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!VPUX.empty()) {
for (auto&& item : VPUX) {
std::vector<std::string> capability = GetCore()->GetMetric(item.deviceName, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), "FP16");
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!iGPU.empty()) {
for (auto&& item : iGPU) {
std::vector<std::string> capability = GetCore()->GetMetric(item.deviceName, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), "FP16");
if (supportNetwork != capability.end()) {
return item;
}
}
} else if (!MYRIAD.empty()) {
for (auto&& item : MYRIAD) {
std::vector<std::string> capability = GetCore()->GetMetric(item.deviceName, METRIC_KEY(OPTIMIZATION_CAPABILITIES));
auto supportNetwork = std::find(capability.begin(), capability.end(), "FP16");
if (supportNetwork != capability.end()) {
return item;
}
}
}
}
if (CPU.empty()) {
IE_THROW() << "Cannot select any device";
}
return CPU[0];
}
} // namespace MultiDevicePlugin
inference-engine/src/multi_device/multi_device_plugin.hpp
+4 -2
View File
@@ -41,9 +41,11 @@ protected:
const MultiDevicePlugin::DeviceName & deviceName) const;
private:
InferenceEngine::IExecutableNetworkInternal::Ptr LoadExeNetworkImpl(const std::string& modelPath,
InferenceEngine::IExecutableNetworkInternal::Ptr LoadNetworkImpl(const std::string& modelPath,
InferenceEngine::CNNNetwork network,
const std::map<std::string, std::string>& config);
const std::map<std::string, std::string>& config,
const std::string &networkPrecision = METRIC_VALUE(FP32));
DeviceInformation SelectDevice(const std::vector<DeviceInformation>& metaDevices, const std::string& networkPrecision = METRIC_VALUE(FP32));
};
} // namespace MultiDevicePlugin
inference-engine/src/plugin_api/cpp_interfaces/interface/ie_internal_plugin_config.hpp
+9
View File
@@ -45,6 +45,15 @@ DECLARE_CONFIG_KEY(CPU_THREADS_PER_STREAM);
*/
DECLARE_CONFIG_KEY(FORCE_DISABLE_CACHE);
/**
* @brief The name for setting work mode internal in MULTI device plugin option.
*
* This option should be used with value only:
* PluginConfigInternalParams::MULTI_MODE_AUTO or PluginConfigInternalParams::MULTI_MODE_LEGACY
*/
DECLARE_CONFIG_KEY(WORK_MODE);
DECLARE_CONFIG_VALUE(MULTI_MODE_AUTO);
} // namespace PluginConfigInternalParams
} // namespace InferenceEngine
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/config.cpp
+10 -15
View File
@@ -30,11 +30,6 @@ namespace {
{{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> AutoConfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_CPU}, {InferenceEngine::PluginConfigParams::KEY_PERF_COUNT, "YES"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_CPU}, {std::string("AUTO_"), "NAN"}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, CorrectConfigTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -53,7 +48,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(AutoConfigs)),
::testing::ValuesIn(MultiConfigs)),
CorrectConfigTests::getTestCaseName);
const std::vector<std::map<std::string, std::string>> inconfigs = {
@@ -71,13 +66,6 @@ namespace {
{InferenceEngine::PluginConfigParams::KEY_DYN_BATCH_LIMIT, "NAN"}}
};
const std::vector<std::map<std::string, std::string>> autoinconfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_CPU},
{InferenceEngine::PluginConfigParams::KEY_CPU_THROUGHPUT_STREAMS, "OFF"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_CPU},
{InferenceEngine::PluginConfigParams::KEY_PERF_COUNT, "ON"}}
};
const std::vector<std::map<std::string, std::string>> multiconf = {
{{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_CPU}}
};
@@ -96,6 +84,13 @@ namespace {
::testing::ValuesIn(multiconf)),
CorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, CorrectConfigAPITests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(multiconf)),
CorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, IncorrectConfigTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -114,7 +109,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoinconfigs)),
::testing::ValuesIn(multiinconfigs)),
IncorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, IncorrectConfigAPITests,
@@ -135,7 +130,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoinconfigs)),
::testing::ValuesIn(multiinconfigs)),
IncorrectConfigAPITests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/core_integration.cpp
+1 -1
View File
@@ -47,7 +47,7 @@ INSTANTIATE_TEST_SUITE_P(
INSTANTIATE_TEST_SUITE_P(
smoke_IEClassGetMetricTest, IEClassGetMetricTest_OPTIMIZATION_CAPABILITIES,
::testing::Values("CPU", "AUTO"));
::testing::Values("CPU"));
INSTANTIATE_TEST_SUITE_P(
smoke_IEClassGetMetricTest, IEClassGetMetricTest_RANGE_FOR_ASYNC_INFER_REQUESTS,
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/core_threading_tests.cpp
+1 -1
View File
@@ -10,7 +10,7 @@ const Params params[] = {
std::tuple<Device, Config>{ CommonTestUtils::DEVICE_CPU, {{ CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES) }}},
std::tuple<Device, Config>{ CommonTestUtils::DEVICE_HETERO, {{ "TARGET_FALLBACK", CommonTestUtils::DEVICE_CPU }}},
std::tuple<Device, Config>{ CommonTestUtils::DEVICE_MULTI, {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_CPU }}},
std::tuple<Device, Config>{ CommonTestUtils::DEVICE_AUTO, {{AUTO_CONFIG_KEY(DEVICE_LIST), CommonTestUtils::DEVICE_CPU }}},
std::tuple<Device, Config>{ CommonTestUtils::DEVICE_AUTO, {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_CPU }}},
};
const Params paramsStreams[] = {
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/exec_graph_info.cpp
+1 -4
View File
@@ -18,9 +18,6 @@ namespace {
const std::vector<std::map<std::string, std::string>> multiConfigs = {
{{ InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> autoConfigs = {
{{ InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_CPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, ExecGraphTests,
::testing::Combine(
@@ -40,6 +37,6 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
::testing::ValuesIn(multiConfigs)),
ExecGraphTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/infer_request.cpp
+1 -5
View File
@@ -24,10 +24,6 @@ namespace {
{{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> Autoconfigs = {
{{ AUTO_CONFIG_KEY(DEVICE_LIST) , CommonTestUtils::DEVICE_CPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -46,7 +42,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(Autoconfigs)),
::testing::ValuesIn(Multiconfigs)),
InferRequestTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/infer_request_callback.cpp
+1 -5
View File
@@ -21,10 +21,6 @@ const std::vector<std::map<std::string, std::string>> multiConfigs = {
{{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> autoConfigs = {
{{ AUTO_CONFIG_KEY(DEVICE_LIST) , CommonTestUtils::DEVICE_CPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, CallbackTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -43,6 +39,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, CallbackTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
::testing::ValuesIn(multiConfigs)),
CallbackTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/infer_request_config.cpp
+14
View File
@@ -60,6 +60,13 @@ namespace {
::testing::ValuesIn(multiConfigs)),
InferConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferConfigTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(multiConfigs)),
InferConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferConfigInTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -74,4 +81,11 @@ namespace {
::testing::ValuesIn(MultiInConfigs)),
InferConfigInTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferConfigInTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(MultiInConfigs)),
InferConfigInTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/infer_request_input.cpp
+1 -5
View File
@@ -25,10 +25,6 @@ namespace {
{InferenceEngine::PluginConfigParams::KEY_CPU_THROUGHPUT_STREAMS, InferenceEngine::PluginConfigParams::CPU_THROUGHPUT_AUTO}}
};
const std::vector<std::map<std::string, std::string>> autoConfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_CPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestInputTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -47,7 +43,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
::testing::ValuesIn(multiConfigs)),
InferRequestInputTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/infer_request_output.cpp
+1 -5
View File
@@ -21,10 +21,6 @@ namespace {
{InferenceEngine::PluginConfigParams::KEY_CPU_THROUGHPUT_STREAMS, InferenceEngine::PluginConfigParams::CPU_THROUGHPUT_AUTO}}
};
const std::vector<std::map<std::string, std::string>> autoConfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_CPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestOutputTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -43,7 +39,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
::testing::ValuesIn(multiConfigs)),
InferRequestOutputTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/ov_core_integration.cpp
+1 -1
View File
@@ -48,7 +48,7 @@ INSTANTIATE_TEST_SUITE_P(
INSTANTIATE_TEST_SUITE_P(
smoke_OVClassGetMetricTest, OVClassGetMetricTest_OPTIMIZATION_CAPABILITIES,
::testing::Values("CPU", "AUTO"));
::testing::Values("CPU"));
INSTANTIATE_TEST_SUITE_P(
smoke_OVClassGetMetricTest, OVClassGetMetricTest_RANGE_FOR_ASYNC_INFER_REQUESTS,
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/set_blob_of_kind.cpp
+2 -3
View File
@@ -15,7 +15,6 @@ const std::vector<FuncTestUtils::BlobKind> blobKinds = {
};
const SetBlobOfKindConfig cpuConfig{}; //nothing special
const SetBlobOfKindConfig autoConfig{};
const SetBlobOfKindConfig multiConfig{{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_CPU}};
const SetBlobOfKindConfig heteroConfig{{ "TARGET_FALLBACK", CommonTestUtils::DEVICE_CPU }};
@@ -34,8 +33,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_SetBlobOfKindMULTI, SetBlobOfKindTest,
INSTANTIATE_TEST_SUITE_P(smoke_SetBlobOfKindAUTO, SetBlobOfKindTest,
::testing::Combine(::testing::ValuesIn(blobKinds),
::testing::Values(CommonTestUtils::DEVICE_AUTO + std::string(":") + CommonTestUtils::DEVICE_CPU),
::testing::Values(autoConfig)),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::Values(multiConfig)),
SetBlobOfKindTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_SetBlobOfKindHETERO, SetBlobOfKindTest,
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/set_preprocess.cpp
+3 -7
View File
@@ -27,10 +27,6 @@ namespace {
{{ InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> autoConfigs = {
{{ InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_CPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, PreprocessTest,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -56,7 +52,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
::testing::ValuesIn(multiConfigs)),
PreprocessTest::getTestCaseName);
@@ -169,7 +165,7 @@ namespace {
::testing::Bool(),
::testing::Bool(),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
::testing::ValuesIn(multiConfigs)),
PreprocessConversionTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, PreprocessDynamicallyInSetBlobTest,
@@ -183,7 +179,7 @@ namespace {
::testing::Values(true), // only SetBlob
::testing::Values(true), // only SetBlob
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
::testing::ValuesIn(multiConfigs)),
PreprocessDynamicallyInSetBlobTest::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/test_plugin.cpp
+3 -11
View File
@@ -21,10 +21,6 @@ namespace {
{{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> AutoConfigs = {
{{ AUTO_CONFIG_KEY(DEVICE_LIST) , CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> configsInput = {
{},
{{InferenceEngine::PluginConfigParams::KEY_CPU_THROUGHPUT_STREAMS, InferenceEngine::PluginConfigParams::CPU_THROUGHPUT_AUTO}}
@@ -36,10 +32,6 @@ namespace {
{InferenceEngine::PluginConfigParams::KEY_CPU_THROUGHPUT_STREAMS, InferenceEngine::PluginConfigParams::CPU_THROUGHPUT_AUTO}}
};
const std::vector<std::map<std::string, std::string>> AutoConfigsInputOutput = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> configsOutput = {
{},
{{InferenceEngine::PluginConfigParams::KEY_CPU_THROUGHPUT_STREAMS, InferenceEngine::PluginConfigParams::CPU_THROUGHPUT_AUTO}}
@@ -64,7 +56,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(AutoConfigsInputOutput)),
::testing::ValuesIn(MultiConfigsInputOutput)),
BehaviorTestOutput::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, BehaviorTests,
@@ -85,7 +77,7 @@ namespace {
::testing::Combine(
::testing::Values(InferenceEngine::Precision::FP32),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(AutoConfigs)),
::testing::ValuesIn(MultiConfigs)),
BehaviorTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, BehaviorTestInput,
@@ -106,7 +98,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(AutoConfigsInputOutput)),
::testing::ValuesIn(MultiConfigsInputOutput)),
BehaviorTestInput::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/cpu/shared_tests_instances/behavior/version.cpp
+1 -5
View File
@@ -14,10 +14,6 @@ namespace {
{{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> Autoconfigs = {
{{ AUTO_CONFIG_KEY(DEVICE_LIST) , CommonTestUtils::DEVICE_CPU}}
};
const std::vector<std::map<std::string, std::string>> Heteroconfigs = {
{{ HETERO_CONFIG_KEY(DUMP_GRAPH_DOT) , CommonTestUtils::DEVICE_CPU}}
};
@@ -40,7 +36,7 @@ namespace {
::testing::Combine(
::testing::Values(InferenceEngine::Precision::FP32),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(Autoconfigs)),
::testing::ValuesIn(Multiconfigs)),
VersionTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, VersionTest,
inference-engine/tests/functional/plugin/gpu/shared_tests_instances/behavior/config.cpp
+3 -27
View File
@@ -35,19 +35,6 @@ namespace {
{{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_DEVICE_ID, "DEVICE_UNKNOWN"}}
};
const std::vector<std::map<std::string, std::string>> autoinconfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_PERF_COUNT, "ON"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_CONFIG_FILE, "unknown_file"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_DUMP_KERNELS, "ON"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_TUNING_MODE, "TUNING_UNKNOWN_MODE"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_DEVICE_ID, "DEVICE_UNKNOWN"}}
};
IE_SUPPRESS_DEPRECATED_END
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, IncorrectConfigTests,
@@ -68,7 +55,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoinconfigs)),
::testing::ValuesIn(multiinconfigs)),
IncorrectConfigTests::getTestCaseName);
@@ -103,17 +90,6 @@ namespace {
{{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> autoconf = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_PERF_COUNT, "YES"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_PERF_COUNT, "YES"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU},
{std::string("AUTO_"), "NAN"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU},
{std::string("AUTO_"), "NAN"}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, CorrectConfigAPITests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -139,7 +115,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoconf)),
::testing::ValuesIn(multiconf)),
CorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, IncorrectConfigAPITests,
@@ -160,7 +136,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoinconfigs)),
::testing::ValuesIn(multiinconfigs)),
IncorrectConfigAPITests::getTestCaseName);
inference-engine/tests/functional/plugin/gpu/shared_tests_instances/behavior/infer_request.cpp
+1 -6
View File
@@ -18,11 +18,6 @@ namespace {
{{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> autoconfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_GPU}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -41,7 +36,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoconfigs)),
::testing::ValuesIn(configs)),
InferRequestTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/gpu/shared_tests_instances/behavior/infer_request_callback.cpp
+1 -16
View File
@@ -19,14 +19,6 @@ const std::vector<std::map<std::string, std::string>> multiConfigs = {
{{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> autoConfigs = {
{{ AUTO_CONFIG_KEY(DEVICE_LIST) , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> auto_cpu_gpu_conf = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, CallbackTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -45,13 +37,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, CallbackTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
CallbackTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoCG_BehaviorTests, CallbackTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(auto_cpu_gpu_conf)),
::testing::ValuesIn(multiConfigs)),
CallbackTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/gpu/shared_tests_instances/behavior/infer_request_input.cpp
+1 -16
View File
@@ -25,14 +25,6 @@ namespace {
InferenceEngine::PluginConfigParams::GPU_THROUGHPUT_AUTO}}
};
const std::vector<std::map<std::string, std::string>> autoConfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> auto_cpu_gpu_conf = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestInputTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -51,14 +43,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
InferRequestInputTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoCG_BehaviorTests, InferRequestInputTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(auto_cpu_gpu_conf)),
::testing::ValuesIn(multiConfigs)),
InferRequestInputTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/gpu/shared_tests_instances/behavior/infer_request_output.cpp
+1 -16
View File
@@ -21,14 +21,6 @@ namespace {
{InferenceEngine::PluginConfigParams::KEY_GPU_THROUGHPUT_STREAMS, InferenceEngine::PluginConfigParams::GPU_THROUGHPUT_AUTO}}
};
const std::vector<std::map<std::string, std::string>> autoConfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> auto_cpu_gpu_conf = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestOutputTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -47,13 +39,6 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
InferRequestOutputTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoCG_BehaviorTests, InferRequestOutputTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(auto_cpu_gpu_conf)),
::testing::ValuesIn(multiConfigs)),
InferRequestOutputTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/gpu/shared_tests_instances/behavior/set_preprocess.cpp
+1 -17
View File
@@ -22,14 +22,6 @@ namespace {
{{ InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> autoConfigs = {
{{ InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> auto_cpu_gpu_conf = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, PreprocessTest,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -48,17 +40,9 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs)),
::testing::ValuesIn(multiConfigs)),
PreprocessTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoCG_BehaviorTests, PreprocessTest,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(auto_cpu_gpu_conf)),
PreprocessTest::getTestCaseName);
const std::vector<InferenceEngine::Precision> ioPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::U8
inference-engine/tests/functional/plugin/gpu/shared_tests_instances/behavior/test_plugin.cpp
+3 -33
View File
@@ -31,14 +31,6 @@ namespace {
{{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> AutoConfigs = {
{{ AUTO_CONFIG_KEY(DEVICE_LIST) , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> auto_cpu_gpu_conf = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> configsInput = {
{},
{{InferenceEngine::PluginConfigParams::KEY_GPU_THROUGHPUT_STREAMS, InferenceEngine::PluginConfigParams::GPU_THROUGHPUT_AUTO}}
@@ -73,14 +65,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(AutoConfigs)),
BehaviorTestOutput::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoCG_BehaviorTests, BehaviorTestOutput,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(auto_cpu_gpu_conf)),
::testing::ValuesIn(MultiConfigsInputOutput)),
BehaviorTestOutput::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, BehaviorTests,
@@ -101,14 +86,7 @@ namespace {
::testing::Combine(
::testing::Values(InferenceEngine::Precision::FP32),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(AutoConfigs)),
BehaviorTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoCG_BehaviorTests, BehaviorTests,
::testing::Combine(
::testing::Values(InferenceEngine::Precision::FP32),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(auto_cpu_gpu_conf)),
::testing::ValuesIn(MultiConfigs)),
BehaviorTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, BehaviorTestInput,
@@ -129,15 +107,7 @@ namespace {
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(AutoConfigs)),
BehaviorTestInput::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoCG_BehaviorTests, BehaviorTestInput,
::testing::Combine(
::testing::ValuesIn(netPrecisionsForAutoCG),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(auto_cpu_gpu_conf)),
::testing::ValuesIn(MultiConfigsInputOutput)),
BehaviorTestInput::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/gpu/shared_tests_instances/behavior/version.cpp
+1 -16
View File
@@ -14,14 +14,6 @@ namespace {
{{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> Autoconfigs = {
{{ AUTO_CONFIG_KEY(DEVICE_LIST) , CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> auto_cpu_gpu_conf = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU}}
};
const std::vector<std::map<std::string, std::string>> Heteroconfigs = {
{{ HETERO_CONFIG_KEY(DUMP_GRAPH_DOT) , CommonTestUtils::DEVICE_GPU}}
};
@@ -44,14 +36,7 @@ namespace {
::testing::Combine(
::testing::Values(InferenceEngine::Precision::FP32),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(Autoconfigs)),
VersionTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoCG_BehaviorTests, VersionTest,
::testing::Combine(
::testing::Values(InferenceEngine::Precision::FP32),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(auto_cpu_gpu_conf)),
::testing::ValuesIn(Multiconfigs)),
VersionTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, VersionTest,
inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/config.cpp
+3 -49
View File
@@ -257,19 +257,11 @@ INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, CorrectConfigTests,
::testing::ValuesIn(getCorrectMultiConfigs())),
CorrectConfigTests::getTestCaseName);
const std::vector<std::map<std::string, std::string>>& getCorrectAutoConfigs() {
static const std::vector<std::map<std::string, std::string>> correctAutoConfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_MYRIAD}, {InferenceEngine::PluginConfigParams::KEY_PERF_COUNT, "YES"}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , CommonTestUtils::DEVICE_MYRIAD}, {std::string("AUTO_"), "NAN"}}
};
return correctAutoConfigs;
}
INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, CorrectConfigTests,
::testing::Combine(
::testing::ValuesIn(getPrecisions()),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(getCorrectAutoConfigs())),
::testing::ValuesIn(getCorrectMultiConfigs())),
CorrectConfigTests::getTestCaseName);
const std::vector<std::pair<std::string, InferenceEngine::Parameter>>& getDefaultEntries() {
@@ -908,44 +900,6 @@ const std::vector<std::map<std::string, std::string>>& getIncorrectMultiConfigs(
return incorrectMultiConfigs;
}
const std::vector<std::map<std::string, std::string>>& getIncorrectAutoConfigs() {
static const std::vector<std::map<std::string, std::string>> incorrectAutoConfigs = {
{
{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_AUTO},
{KEY_LOG_LEVEL, "INCORRECT_LOG_LEVEL"},
},
{
{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_AUTO},
{InferenceEngine::MYRIAD_PROTOCOL, "BLUETOOTH"}
},
{
{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_AUTO},
{InferenceEngine::MYRIAD_ENABLE_HW_ACCELERATION, "ON"}
},
{
{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_AUTO},
{InferenceEngine::MYRIAD_ENABLE_RECEIVING_TENSOR_TIME, "ON"}
},
{
{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_AUTO},
{KEY_PERF_COUNT, "ON"}
},
{
{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_AUTO},
{InferenceEngine::MYRIAD_THROUGHPUT_STREAMS, "ONE"}
},
{
{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_AUTO},
{KEY_EXCLUSIVE_ASYNC_REQUESTS, "ON"}
},
{
{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_AUTO},
{InferenceEngine::MYRIAD_DDR_TYPE, "1GB"}
},
};
return incorrectAutoConfigs;
}
INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, IncorrectConfigTests,
::testing::Combine(
::testing::ValuesIn(getPrecisions()),
@@ -957,7 +911,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, IncorrectConfigTests,
::testing::Combine(
::testing::ValuesIn(getPrecisions()),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(getIncorrectAutoConfigs())),
::testing::ValuesIn(getIncorrectMultiConfigs())),
IncorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, IncorrectConfigSingleOptionTests,
@@ -998,6 +952,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, IncorrectConfigAPITests,
::testing::Combine(
::testing::ValuesIn(getPrecisions()),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(getIncorrectAutoConfigs())),
::testing::ValuesIn(getIncorrectMultiConfigs())),
IncorrectConfigAPITests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/myriad/shared_tests_instances/behavior/infer_request.cpp
+1 -6
View File
@@ -17,11 +17,6 @@ const std::vector<std::map<std::string, std::string>> configs = {
{{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, CommonTestUtils::DEVICE_MYRIAD}}
};
const std::vector<std::map<std::string, std::string>> autoconfigs = {
{{InferenceEngine::KEY_AUTO_DEVICE_LIST, CommonTestUtils::DEVICE_MYRIAD}},
{{InferenceEngine::KEY_AUTO_DEVICE_LIST , std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_MYRIAD}}
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -40,6 +35,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestTests,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoconfigs)),
::testing::ValuesIn(configs)),
InferRequestTests::getTestCaseName);
} // namespace
inference-engine/tests/functional/plugin/shared/include/behavior/exec_graph_info.hpp
+6 -3
View File
@@ -58,7 +58,8 @@ TEST_P(ExecGraphTests, CheckExecGraphInfoBeforeExecution) {
// Create CNNNetwork from ngrpah::Function
InferenceEngine::CNNNetwork cnnNet(function);
InferenceEngine::CNNNetwork execGraph;
if (targetDevice != CommonTestUtils::DEVICE_MULTI &&
if (targetDevice != CommonTestUtils::DEVICE_AUTO &&
targetDevice != CommonTestUtils::DEVICE_MULTI &&
targetDevice != CommonTestUtils::DEVICE_TEMPLATE &&
targetDevice != CommonTestUtils::DEVICE_GNA) {
// Load CNNNetwork to target plugins
@@ -126,7 +127,8 @@ TEST_P(ExecGraphTests, CheckExecGraphInfoAfterExecution) {
// Create CNNNetwork from ngrpah::Function
InferenceEngine::CNNNetwork cnnNet(function);
InferenceEngine::CNNNetwork execGraph;
if (targetDevice != CommonTestUtils::DEVICE_MULTI &&
if (targetDevice != CommonTestUtils::DEVICE_AUTO &&
targetDevice != CommonTestUtils::DEVICE_MULTI &&
targetDevice != CommonTestUtils::DEVICE_TEMPLATE &&
targetDevice != CommonTestUtils::DEVICE_GNA) {
// Load CNNNetwork to target plugins
@@ -206,7 +208,8 @@ TEST_P(ExecGraphTests, CheckExecGraphInfoSerialization) {
// Create CNNNetwork from ngrpah::Function
InferenceEngine::CNNNetwork cnnNet(function);
InferenceEngine::CNNNetwork execGraph;
if (targetDevice != CommonTestUtils::DEVICE_MULTI &&
if (targetDevice != CommonTestUtils::DEVICE_AUTO &&
targetDevice != CommonTestUtils::DEVICE_MULTI &&
targetDevice != CommonTestUtils::DEVICE_TEMPLATE &&
targetDevice != CommonTestUtils::DEVICE_GNA) {
// Load CNNNetwork to target plugins
inference-engine/tests/functional/shared_test_classes/src/subgraph/reduce_eltwise.cpp
+1 -2
View File
@@ -31,8 +31,7 @@ void ReduceEltwiseTest::SetUp() {
CommonTestUtils::OpType opType;
bool keepDims;
InferenceEngine::Precision netPrecision;
std::string targetName;
std::tie(inputShape, axes, opType, keepDims, netPrecision, targetName) = this->GetParam();
std::tie(inputShape, axes, opType, keepDims, netPrecision, targetDevice) = this->GetParam();
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
auto paramOuts = ngraph::helpers::convert2OutputVector(