inference-engine/src/inference_engine/cpp_interfaces/base/ie_executable_network_base.hpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 /**
   6  * \brief inference engine executanle network API wrapper, to be used by particular implementors
   7  * \file ie_executable_network_base.hpp
   8  */
   9
  10 #pragma once
  11
  12 #include <vector>
  13 #include <memory>
  14 #include <map>
  15 #include <string>
  16 #include <cpp_interfaces/interface/ie_imemory_state_internal.hpp>
  17 #include <cpp_interfaces/base/ie_memory_state_base.hpp>
  18 #include "cpp_interfaces/exception2status.hpp"
  19
  20 namespace InferenceEngine {
  21
  22 /**
  23  * @brief cpp interface for executable network, to avoid dll boundaries and simplify internal development
  24  * @tparam T Minimal CPP implementation of IExecutableNetwork (e.g. ExecutableNetworkInternal)
  25  */
  26 template<class T>
  27 class ExecutableNetworkBase : public IExecutableNetwork {
  28     std::shared_ptr<T> _impl;
  29
  30 public:
  31     typedef std::shared_ptr<ExecutableNetworkBase<T>> Ptr;
  32
  33     explicit ExecutableNetworkBase(std::shared_ptr<T> impl) {
  34         if (impl.get() == nullptr) {
  35             THROW_IE_EXCEPTION << "implementation not defined";
  36         }
  37         _impl = impl;
  38     }
  39
  40     StatusCode GetOutputsInfo(ConstOutputsDataMap &outs, ResponseDesc *resp) const noexcept override {
  41         TO_STATUS(outs = _impl->GetOutputsInfo());
  42     }
  43
  44     StatusCode GetInputsInfo(ConstInputsDataMap &inputs, ResponseDesc *resp) const noexcept override {
  45         TO_STATUS(inputs = _impl->GetInputsInfo());
  46     }
  47
  48     StatusCode CreateInferRequest(IInferRequest::Ptr &req, ResponseDesc *resp) noexcept override {
  49         TO_STATUS(_impl->CreateInferRequest(req));
  50     }
  51
  52     StatusCode Export(const std::string &modelFileName, ResponseDesc *resp) noexcept override {
  53         TO_STATUS(_impl->Export(modelFileName));
  54     }
  55
  56     StatusCode GetMappedTopology(std::map<std::string, std::vector<PrimitiveInfo::Ptr>> &deployedTopology,
  57                                  ResponseDesc *resp) noexcept override {
  58         TO_STATUS(_impl->GetMappedTopology(deployedTopology));
  59     }
  60
  61     StatusCode GetExecGraphInfo(ICNNNetwork::Ptr &graphPtr, ResponseDesc *resp) noexcept override {
  62         TO_STATUS(_impl->GetExecGraphInfo(graphPtr));
  63     }
  64
  65     StatusCode  QueryState(IMemoryState::Ptr & pState, size_t idx
  66         , ResponseDesc *resp) noexcept override {
  67         try {
  68             auto v = _impl->QueryState();
  69             if (idx >= v.size()) {
  70                 return OUT_OF_BOUNDS;
  71             }
  72             pState = std::make_shared<MemoryStateBase<IMemoryStateInternal>>(v[idx]);
  73             return OK;
  74         } catch (const std::exception & ex) {\
  75             return InferenceEngine::DescriptionBuffer(GENERAL_ERROR, resp) << ex.what();\
  76         } catch (...) {\
  77             return InferenceEngine::DescriptionBuffer(UNEXPECTED);\
  78         }
  79     }
  80
  81     void Release() noexcept override {
  82         delete this;
  83     }
  84
  85     // Need for unit tests only - TODO: unit tests should test using public API, non having details
  86     const std::shared_ptr<T> getImpl() const {
  87         return _impl;
  88     }
  89
  90 private:
  91     ~ExecutableNetworkBase() = default;
  92 };
  93
  94 template <class T>
  95 inline typename ExecutableNetworkBase<T>::Ptr make_executable_network(std::shared_ptr<T> impl) {
  96     typename ExecutableNetworkBase<T>::Ptr net(new ExecutableNetworkBase<T>(impl), [](IExecutableNetwork * p) {
  97         p->Release();
  98     });
  99     return net;
 100 }
 101
 102 }  // namespace InferenceEngine