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

[IE][VPU]: Improves myriad plugin API (#2816)

Browse Source 
LoadNetwork takes network argument by constant reference.
Myriad plugin implementation applies transformations to
given network in order to get compiled model.
Transformations take network argument by non-constant
reference, so at some point of time network copy must be
acquired. ICNNNetwork is neither copyable nor movable, so
the only way to get network copy is using special utility
returning std::shared_ptr.

Myriad plugin does not expose any ownership strategy,
so prefers to take network argument by simple reference.
Plugin also requires nGraph -> CNN conversion during
LoadNetwork implementation. Conversion utilities returns
std::shared_ptr, which makes plugin to use workaround for
lifetime of converted object (to have 2 "pointers" to
network: raw pointer to input network and smart pointer to
converted network). Such workarounds make code more
error-prone, because using wrong pointer to semantically
the same object may lead to unexpected results.

To overcome these issues API has been changed in a way to
make interfaces more clear (do not expose ownership strategy
or mutability) and get rid of unnecessary workarounds.

Signed-off-by: Gladilov, Gleb <gleb.gladilov@intel.com>
This commit is contained in:
Gladilov, Gleb 2020-10-28 11:14:14 +03:00 committed by GitHub
parent 91afa14901
commit 18f7e4f4f0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 43 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
inference-engine/src/vpu/graph_transformer/include/vpu/frontend/frontend.hpp
View File

@ -32,9 +32,9 @@ public:
explicit FrontEnd(StageBuilder::Ptr stageBuilder, const ie::ICore* core); explicit FrontEnd(StageBuilder::Ptr stageBuilder, const ie::ICore* core);
ModelPtr buildInitialModel(ie::ICNNNetwork& network); ModelPtr buildInitialModel(const ie::ICNNNetwork& network);
std::set<std::string> checkSupportedLayers(ie::ICNNNetwork& network); std::set<std::string> checkSupportedLayers(const ie::ICNNNetwork& network);
const std::vector<ie::CNNLayerPtr>& origLayers() const { const std::vector<ie::CNNLayerPtr>& origLayers() const {
return _ieParsedNetwork.orderedLayers; return _ieParsedNetwork.orderedLayers;
@ -45,11 +45,11 @@ public:
// //
private: private:
ModelPtr runCommonPasses(const ie::ICNNNetwork& network);
using SupportedLayerCallback = std::function<void(const ie::CNNLayerPtr&)>; using SupportedLayerCallback = std::function<void(const ie::CNNLayerPtr&)>;
using UnsupportedLayerCallback = std::function<void(const Model&, const ie::CNNLayerPtr&, const DataVector&, const DataVector&, const std::string&)>; using UnsupportedLayerCallback = std::function<void(const Model&, const ie::CNNLayerPtr&, const DataVector&, const DataVector&, const std::string&)>;
ModelPtr runCommonPasses(ie::ICNNNetwork::Ptr network, const UnsupportedLayerCallback& unsupportedLayer,
ModelPtr runCommonPasses(ie::ICNNNetwork& network);
ModelPtr runCommonPasses(ie::ICNNNetwork& network, const UnsupportedLayerCallback& unsupportedLayer,
const SupportedLayerCallback& supportedLayer = nullptr); const SupportedLayerCallback& supportedLayer = nullptr);
// //

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

@ -163,28 +163,17 @@ struct CompiledGraph final {
// compileNetwork // compileNetwork
// //
CompiledGraph::Ptr compileNetwork( CompiledGraph::Ptr compileNetwork(const ie::ICNNNetwork& network, Platform platform, const CompilationConfig& config, const Logger::Ptr& log,
ie::ICNNNetwork& network, const ie::ICore* core);
Platform platform,
const CompilationConfig& config,
const Logger::Ptr& log,
const ie::ICore* core);
CompiledGraph::Ptr compileSubNetwork( CompiledGraph::Ptr compileSubNetwork(const ie::ICNNNetwork& network, const CompilationConfig& subConfig, const ie::ICore* core);
ie::ICNNNetwork& network,
const CompilationConfig& subConfig,
const ie::ICore* core);
// //
// getSupportedLayers // getSupportedLayers
// //
std::set<std::string> getSupportedLayers( std::set<std::string> getSupportedLayers(const ie::ICNNNetwork& network, Platform platform, const CompilationConfig& config, const Logger::Ptr& log,
const ie::ICNNNetwork& network, const ie::ICore* core);
Platform platform,
const CompilationConfig& config,
const Logger::Ptr& log,
const ie::ICore* core);
// //
// Blob version and checks // Blob version and checks

61
inference-engine/src/vpu/graph_transformer/src/frontend/frontend.cpp
View File

@ -35,6 +35,7 @@
#include "vpu/ngraph/transformations/dynamic_to_static_shape.hpp" #include "vpu/ngraph/transformations/dynamic_to_static_shape.hpp"
#include "vpu/ngraph/transformations/eliminate_shapeof_after_dsr.hpp" #include "vpu/ngraph/transformations/eliminate_shapeof_after_dsr.hpp"
#include <vpu/ngraph/operations/dynamic_shape_resolver.hpp> #include <vpu/ngraph/operations/dynamic_shape_resolver.hpp>
#include <legacy/ie_util_internal.hpp>
namespace vpu { namespace vpu {
@ -133,7 +134,7 @@ FrontEnd::FrontEnd(StageBuilder::Ptr stageBuilder, const ie::ICore* core)
VPU_THROW_UNLESS(_core != nullptr, "Argument core is null"); VPU_THROW_UNLESS(_core != nullptr, "Argument core is null");
} }
ModelPtr FrontEnd::buildInitialModel(ie::ICNNNetwork& network) { ModelPtr FrontEnd::buildInitialModel(const ie::ICNNNetwork& network) {
VPU_PROFILE(buildInitialModel); VPU_PROFILE(buildInitialModel);
const auto& env = CompileEnv::get(); const auto& env = CompileEnv::get();
@ -148,7 +149,6 @@ bool FrontEnd::isLayerSupported(const std::string& type) {
} }
ie::ICNNNetwork::Ptr FrontEnd::convertNetwork(ie::ICNNNetwork& network) { ie::ICNNNetwork::Ptr FrontEnd::convertNetwork(ie::ICNNNetwork& network) {
std::shared_ptr<ie::ICNNNetwork> convertedNetwork;
// disable transformations for some cases // disable transformations for some cases
const auto transformationsPredicate = [](const std::shared_ptr<const ngraph::Node>& node) -> bool { const auto transformationsPredicate = [](const std::shared_ptr<const ngraph::Node>& node) -> bool {
const bool casesWithDynamicOrStaticUsage = const bool casesWithDynamicOrStaticUsage =
@ -185,11 +185,10 @@ ie::ICNNNetwork::Ptr FrontEnd::convertNetwork(ie::ICNNNetwork& network) {
vpu::MergeSubsequentDSROperations().run_on_function(nGraphFunc); vpu::MergeSubsequentDSROperations().run_on_function(nGraphFunc);
convertedNetwork = InferenceEngine::details::convertFunctionToICNNNetwork(nGraphFunc, network); return InferenceEngine::details::convertFunctionToICNNNetwork(nGraphFunc, network);
return convertedNetwork;
} }
std::set<std::string> FrontEnd::checkSupportedLayers(ie::ICNNNetwork& network) { std::set<std::string> FrontEnd::checkSupportedLayers(const ie::ICNNNetwork& network) {
VPU_PROFILE(checkSupportedLayers); VPU_PROFILE(checkSupportedLayers);
const auto& env = CompileEnv::get(); const auto& env = CompileEnv::get();
@ -212,7 +211,7 @@ std::set<std::string> FrontEnd::checkSupportedLayers(ie::ICNNNetwork& network) {
_stageBuilder->addNoneStage(model, layer->name, layer, inputs, outputs); _stageBuilder->addNoneStage(model, layer->name, layer, inputs, outputs);
}; };
runCommonPasses(network, onUnsupportedLayer, onSupportedLayer); runCommonPasses(cloneNetwork(network), onUnsupportedLayer, onSupportedLayer);
return supportedLayers; return supportedLayers;
} }
@ -367,22 +366,14 @@ void FrontEnd::defaultOnUnsupportedLayerCallback(const Model& model, const ie::C
_stageBuilder->addNoneStage(model, layer->name, layer, inputs, outputs); _stageBuilder->addNoneStage(model, layer->name, layer, inputs, outputs);
} }
ModelPtr FrontEnd::runCommonPasses(ie::ICNNNetwork& network) { ModelPtr FrontEnd::runCommonPasses(const ie::ICNNNetwork& network) {
return runCommonPasses(network, [this](const Model& model, const ie::CNNLayerPtr& layer, return runCommonPasses(cloneNetwork(network),
const DataVector& inputs, const DataVector& outputs, const std::string& extraMessage) [this](const Model& model, const ie::CNNLayerPtr& layer, const DataVector& inputs, const DataVector& outputs, const std::string& extraMessage) {
{ defaultOnUnsupportedLayerCallback(model, layer, inputs, outputs, extraMessage); }); defaultOnUnsupportedLayerCallback(model, layer, inputs, outputs, extraMessage);});
} }
ModelPtr FrontEnd::runCommonPasses(ie::ICNNNetwork& network, const UnsupportedLayerCallback& unsupportedLayer, const SupportedLayerCallback& supportedLayer) { ModelPtr FrontEnd::runCommonPasses(ie::ICNNNetwork::Ptr network,
// NGraph -> CNN conversion may be called in 2 different moments: at const UnsupportedLayerCallback& unsupportedLayer, const SupportedLayerCallback& supportedLayer) {
// the beginning if conversion was forced by configuration or after detect
// network batch and precision conversions. Conversion utility
// returns std::shared_ptr. ICNNNetwork is neither copyable nor movable.
// As a result, it is impossible to overwrite given "network" argument.
// Do not use network parameter in this function to avoid using wrong network
// reference (e.g. original instead of converted).
auto* originalOrConvertNetwork = &network;
const auto& env = CompileEnv::get(); const auto& env = CompileEnv::get();
// //
@ -416,7 +407,7 @@ ModelPtr FrontEnd::runCommonPasses(ie::ICNNNetwork& network, const UnsupportedLa
// Create new VPU model // Create new VPU model
// //
const auto model = std::make_shared<ModelObj>(originalOrConvertNetwork->getName()); auto model = std::make_shared<ModelObj>(network->getName());
model->attrs().set<int>("index", g_counter.fetch_add(1)); model->attrs().set<int>("index", g_counter.fetch_add(1));
model->attrs().set<Resources>("resources", env.resources); model->attrs().set<Resources>("resources", env.resources);
@ -425,39 +416,35 @@ ModelPtr FrontEnd::runCommonPasses(ie::ICNNNetwork& network, const UnsupportedLa
// Update IE Network // Update IE Network
// //
std::shared_ptr<ie::ICNNNetwork> convertedNetwork;
{ {
env.log->trace("Update IE Network"); env.log->trace("Update IE Network");
VPU_LOGGER_SECTION(env.log); VPU_LOGGER_SECTION(env.log);
if (originalOrConvertNetwork->getFunction() && env.config.forceDeprecatedCnnConversion) { if (network->getFunction() && env.config.forceDeprecatedCnnConversion) {
convertedNetwork = convertNetwork(*originalOrConvertNetwork); network = convertNetwork(*network);
originalOrConvertNetwork = convertedNetwork.get();
} }
detectNetworkBatch(*originalOrConvertNetwork, model); detectNetworkBatch(*network, model);
if (originalOrConvertNetwork->getFunction()) { if (network->getFunction()) {
convertedNetwork = convertNetwork(*originalOrConvertNetwork); network = convertNetwork(*network);
originalOrConvertNetwork = convertedNetwork.get();
} }
ie::NetPass::ConvertPrecision(*originalOrConvertNetwork, ie::Precision::I64, ie::Precision::I32); ie::NetPass::ConvertPrecision(*network, ie::Precision::I64, ie::Precision::I32);
ie::NetPass::ConvertPrecision(*originalOrConvertNetwork, ie::Precision::U32, ie::Precision::I32); ie::NetPass::ConvertPrecision(*network, ie::Precision::U32, ie::Precision::I32);
ie::NetPass::ConvertPrecision(*originalOrConvertNetwork, ie::Precision::U64, ie::Precision::I32); ie::NetPass::ConvertPrecision(*network, ie::Precision::U64, ie::Precision::I32);
ie::NetPass::ConvertPrecision(*originalOrConvertNetwork, ie::Precision::BOOL, ie::Precision::I32); ie::NetPass::ConvertPrecision(*network, ie::Precision::BOOL, ie::Precision::I32);
removeConstLayers(*originalOrConvertNetwork); removeConstLayers(*network);
unrollLoops(*originalOrConvertNetwork); unrollLoops(*network);
} }
// //
// Parse IR Network // Parse IR Network
// //
_ieParsedNetwork = parseNetwork(*originalOrConvertNetwork); _ieParsedNetwork = parseNetwork(*network);
// //
// Process internal VPU Model // Process internal VPU Model

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

@ -144,8 +144,7 @@ void CompileEnv::free() {
namespace { namespace {
CompiledGraph::Ptr compileImpl(ie::ICNNNetwork& network, CompiledGraph::Ptr compileImpl(const ie::ICNNNetwork& network, const ie::ICore* core) {
const ie::ICore* core) {
const auto& env = CompileEnv::get(); const auto& env = CompileEnv::get();
env.log->debug("Compile network [%s]", network.getName()); env.log->debug("Compile network [%s]", network.getName());
@ -193,12 +192,8 @@ CompiledGraph::Ptr compileImpl(const Model& model) {
} // namespace } // namespace
CompiledGraph::Ptr compileNetwork( CompiledGraph::Ptr compileNetwork(const ie::ICNNNetwork& network, Platform platform, const CompilationConfig& config, const Logger::Ptr& log,
ie::ICNNNetwork& network, const ie::ICore* core) {
Platform platform,
const CompilationConfig& config,
const Logger::Ptr& log,
const ie::ICore* core) {
CompileEnv::init(platform, config, log); CompileEnv::init(platform, config, log);
AutoScope autoDeinit([] { AutoScope autoDeinit([] {
CompileEnv::free(); CompileEnv::free();
@ -224,10 +219,7 @@ CompiledGraph::Ptr compileModel(
return compileImpl(model); return compileImpl(model);
} }
CompiledGraph::Ptr compileSubNetwork( CompiledGraph::Ptr compileSubNetwork(const ie::ICNNNetwork& network, const CompilationConfig& subConfig, const ie::ICore* core) {
ie::ICNNNetwork& network,
const CompilationConfig& subConfig,
const ie::ICore* core) {
VPU_PROFILE(compileSubNetwork); VPU_PROFILE(compileSubNetwork);
const auto& env = CompileEnv::get(); const auto& env = CompileEnv::get();
@ -261,10 +253,7 @@ std::set<std::string> getSupportedLayers(
auto stageBuilder = std::make_shared<StageBuilder>(); auto stageBuilder = std::make_shared<StageBuilder>();
auto frontEnd = std::make_shared<FrontEnd>(stageBuilder, core); auto frontEnd = std::make_shared<FrontEnd>(stageBuilder, core);
return frontEnd->checkSupportedLayers(network);
auto clonedNetworkImpl = ie::cloneNet(network);
return frontEnd->checkSupportedLayers(*clonedNetworkImpl);
} }
int DeviceResources::numShaves(const Platform& platform) { int DeviceResources::numShaves(const Platform& platform) {

4
inference-engine/src/vpu/myriad_plugin/myriad_executable_network.cpp
View File

@ -51,7 +51,7 @@ ExecutableNetwork::ExecutableNetwork(
} }
ExecutableNetwork::ExecutableNetwork( ExecutableNetwork::ExecutableNetwork(
ICNNNetwork& network, const ICNNNetwork& network,
std::shared_ptr<IMvnc> mvnc, std::shared_ptr<IMvnc> mvnc,
std::vector<DevicePtr>& devicePool, std::vector<DevicePtr>& devicePool,
const MyriadConfig& config, const MyriadConfig& config,
@ -84,7 +84,7 @@ ExecutableNetwork::ExecutableNetwork(
return; return;
} }
auto networkName = network.getName(); const auto& networkName = network.getName();
_executor->allocateGraph(_device, _graphDesc, _graphBlob, compiledGraph->blobHeader, compiledGraph->numActiveStages, networkName, _actualNumExecutors); _executor->allocateGraph(_device, _graphDesc, _graphBlob, compiledGraph->blobHeader, compiledGraph->numActiveStages, networkName, _actualNumExecutors);
if (_config.exclusiveAsyncRequests()) { if (_config.exclusiveAsyncRequests()) {
ExecutorManager *executorManager = ExecutorManager::getInstance(); ExecutorManager *executorManager = ExecutorManager::getInstance();

2
inference-engine/src/vpu/myriad_plugin/myriad_executable_network.h
View File

@ -32,7 +32,7 @@ class ExecutableNetwork : public InferenceEngine::ExecutableNetworkThreadSafeDef
public: public:
typedef std::shared_ptr<ExecutableNetwork> Ptr; typedef std::shared_ptr<ExecutableNetwork> Ptr;
explicit ExecutableNetwork(InferenceEngine::ICNNNetwork &network, explicit ExecutableNetwork(const InferenceEngine::ICNNNetwork& network,
std::shared_ptr<IMvnc> mvnc, std::shared_ptr<IMvnc> mvnc,
std::vector<DevicePtr> &devicePool, std::vector<DevicePtr> &devicePool,
const MyriadConfig& config, const MyriadConfig& config,

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

@ -39,8 +39,7 @@ ExecutableNetworkInternal::Ptr Engine::LoadExeNetworkImpl(const ICNNNetwork& net
auto parsedConfigCopy = _parsedConfig; auto parsedConfigCopy = _parsedConfig;
parsedConfigCopy.update(config); parsedConfigCopy.update(config);
auto clonedNetwork = cloneNetwork(network); return std::make_shared<ExecutableNetwork>(network, _mvnc, _devicePool, parsedConfigCopy, GetCore());
return std::make_shared<ExecutableNetwork>(*clonedNetwork, _mvnc, _devicePool, parsedConfigCopy, GetCore());
} }
void Engine::SetConfig(const std::map<std::string, std::string> &config) { void Engine::SetConfig(const std::map<std::string, std::string> &config) {