Further caching implementation

docs/template_plugin/src/template_plugin.cpp

@@ -240,6 +240,7 @@ InferenceEngine::Parameter Plugin::GetMetric(const std::string& name, const std:
             METRIC_KEY(SUPPORTED_CONFIG_KEYS),
             METRIC_KEY(FULL_DEVICE_NAME),
             METRIC_KEY(OPTIMIZATION_CAPABILITIES),
+            METRIC_KEY(IMPORT_EXPORT_SUPPORT),
             METRIC_KEY(DEVICE_ARCHITECTURE),
             METRIC_KEY(RANGE_FOR_ASYNC_INFER_REQUESTS) };
         IE_SET_METRIC_RETURN(SUPPORTED_METRICS, supportedMetrics);
@@ -270,6 +271,8 @@ InferenceEngine::Parameter Plugin::GetMetric(const std::string& name, const std:
         // TODO: fill actual device architecture based on DEVICE_ID passed to `options`
         std::string deviceArch = "TEMPLATE";
         IE_SET_METRIC_RETURN(DEVICE_ARCHITECTURE, deviceArch);
+    } else if (METRIC_KEY(IMPORT_EXPORT_SUPPORT) == name) {
+        IE_SET_METRIC_RETURN(IMPORT_EXPORT_SUPPORT, true);
     } else if (METRIC_KEY(RANGE_FOR_ASYNC_INFER_REQUESTS) == name) {
         // TODO: fill with actual values
         using uint = unsigned int;

inference-engine/include/ie_plugin_config.hpp

@@ -148,6 +148,11 @@ DECLARE_METRIC_KEY(NUMBER_OF_EXEC_INFER_REQUESTS, unsigned int);
  */
 DECLARE_METRIC_KEY(DEVICE_ARCHITECTURE, std::string);
 
+/**
+ * @brief Metric which defines support of import/export functions by plugin
+ */
+DECLARE_METRIC_KEY(IMPORT_EXPORT_SUPPORT, bool);
+
 /**
  * @brief Metric to get a name of network. String value is "NETWORK_NAME".
  */

inference-engine/samples/benchmark_app/main.cpp

@@ -307,7 +307,7 @@ int main(int argc, char *argv[]) {
         for (auto&& item : config) {
             ie.SetConfig(item.second, item.first);
         }
-
+        ie.SetConfig({ {CONFIG_KEY(CACHE_DIR), "cacheBenchmark"} });
         auto double_to_string = [] (const double number) {
             std::stringstream ss;
             ss << std::fixed << std::setprecision(2) << number;

inference-engine/src/inference_engine/compilation_context.hpp

@@ -44,12 +44,12 @@ struct NetworkCompilationContext final {
         } catch (const std::bad_cast &) {
             // IR v7 or older is passed: cannot cast to CNNNetworkNGraphImpl
             m_cachingIsAvailable = false;
-            std::cerr << "IR v7 is passed; skip import and export" << std::endl;
+            std::cerr << "mnosov: IR v7 is passed; skip import and export" << std::endl;
         } catch (const ngraph::ngraph_error & ex) {
             // failed to serialize the model - caching is not available
             m_cachingIsAvailable = false;
             std::cerr << ex.what() << std::endl;
-            std::cerr << "failed to serialize the model; skip import and export" << std::endl;
+            std::cerr << "mnosov: failed to serialize the model; skip import and export" << std::endl;
         }
 
         if (!m_cachingIsAvailable)
@@ -91,7 +91,7 @@ struct NetworkCompilationContext final {
 
         // compute hash on weights if any
         if (!m_weights.empty()) {
-            std::cerr << "Compute hash on weights" << std::endl;
+            std::cerr << "mnosov: Compute hash on weights" << std::endl;
             for (const auto & c : m_weights) {
                 auto data = reinterpret_cast<const std::uint8_t *>(c->get_data_ptr());
                 auto data_size = c->get_element_type().size() * ngraph::shape_size(c->get_shape());

inference-engine/src/vpu/myriad_plugin/myriad_metrics.cpp

@@ -27,6 +27,7 @@ MyriadMetrics::MyriadMetrics() {
         METRIC_KEY(RANGE_FOR_ASYNC_INFER_REQUESTS),
         METRIC_KEY(DEVICE_THERMAL),
         METRIC_KEY(DEVICE_ARCHITECTURE),
+        METRIC_KEY(IMPORT_EXPORT_SUPPORT),
     };
 
 IE_SUPPRESS_DEPRECATED_START

inference-engine/src/vpu/myriad_plugin/myriad_plugin.cpp

@@ -209,6 +209,8 @@ InferenceEngine::Parameter Engine::GetMetric(const std::string& name,
         IE_SET_METRIC_RETURN(RANGE_FOR_ASYNC_INFER_REQUESTS, _metrics->RangeForAsyncInferRequests(_config));
     } else if (name == METRIC_KEY(DEVICE_ARCHITECTURE)) {
         IE_SET_METRIC_RETURN(DEVICE_ARCHITECTURE, _metrics->DeviceArchitecture());
+    } else if (name == METRIC_KEY(IMPORT_EXPORT_SUPPORT)) {
+        IE_SET_METRIC_RETURN(IMPORT_EXPORT_SUPPORT, true);
     } else if (name == METRIC_KEY(DEVICE_THERMAL)) {
         const auto& device = getDeviceByName(getSpecifiedDeviceName());
         if (device != nullptr) {

inference-engine/tests/functional/inference_engine/caching_test.cpp

@@ -49,7 +49,17 @@ class CachingInferencePlugin : public InferenceEngine::InferencePluginInternal {
 public:
     int m_loadNetworkCalled = 0;
     int m_importNetworkCalled = 0;
+    mutable int m_getMetricCalled = 0;
     int m_exportCalled = 0;
+    bool m_supportImportExport = true;
+
+    void resetCounters() {
+        m_loadNetworkCalled = 0;
+        m_importNetworkCalled = 0;
+        m_getMetricCalled = 0;
+        m_exportCalled = 0;
+    }
+
     ~CachingInferencePlugin() override = default;
 
     ExecutableNetworkInternal::Ptr LoadExeNetworkImpl(const CNNNetwork& network,
@@ -79,7 +89,13 @@ class CachingInferencePlugin : public InferenceEngine::InferencePluginInternal {
 
     Parameter GetMetric(const std::string& name, const std::map<std::string, InferenceEngine::Parameter>& options) const override {
         if (METRIC_KEY(SUPPORTED_METRICS) == name) {
-            return std::vector<std::string> {};
+            std::vector<std::string> supportedMetrics = {
+                METRIC_KEY(IMPORT_EXPORT_SUPPORT)
+            };
+            return supportedMetrics;
+        } else if (METRIC_KEY(IMPORT_EXPORT_SUPPORT) == name) {
+            m_getMetricCalled++;
+            return m_supportImportExport;
         } else {
             THROW_IE_EXCEPTION << "Unsupported device metric: " << name;
         }
@@ -119,7 +135,6 @@ class CachingTest : public ::testing::Test {
         FuncTestUtils::TestModel::generateTestModel(modelName, weightsName);
 
         ie.RegisterPlugin(std::string("mock_engine") + IE_BUILD_POSTFIX, deviceName);
-        ie.SetConfig({ {CONFIG_KEY(CACHE_DIR), "testCache"} });
     }
 
     void TearDown() override {
@@ -132,6 +147,10 @@ class CachingTest : public ::testing::Test {
         ie.UnregisterPlugin(deviceName);
     }
 
+    void enableCacheConfig() {
+        ie.SetConfig({ {CONFIG_KEY(CACHE_DIR), "testCache"} });
+    }
+
 private:
     template <class T>
     std::function<T> make_std_function(const std::string& functionName) {
@@ -141,6 +160,7 @@ class CachingTest : public ::testing::Test {
 };
 
 TEST_F(CachingTest, Test1) {
+    enableCacheConfig();
     auto performReadAndLoad = [&] {
         auto cnnNetwork = ie.ReadNetwork(modelName);
         auto exeNet = ie.LoadNetwork(cnnNetwork, deviceName);
@@ -150,20 +170,83 @@ TEST_F(CachingTest, Test1) {
     { // Step 1: read and load network without cache
         performReadAndLoad();
 
-        EXPECT_GT(m_plugin->m_loadNetworkCalled, 0); // verify: 'load was called'
-        EXPECT_GT(m_plugin->m_exportCalled, 0); // verify: 'export was called'
+        EXPECT_GT(m_plugin->m_getMetricCalled, 0); // verify: 'getMetric was called'
+        EXPECT_EQ(m_plugin->m_loadNetworkCalled, 1); // verify: 'load was called'
+        EXPECT_EQ(m_plugin->m_exportCalled, 1); // verify: 'export was called'
+        EXPECT_EQ(m_plugin->m_importNetworkCalled, 0); // verify: 'import was not called'
     }
 
-    m_plugin->m_loadNetworkCalled = 0;
-    m_plugin->m_exportCalled = 0;
-    m_plugin->m_importNetworkCalled = 0;
+    m_plugin->resetCounters();
 
     { // Step 2: same load, but now cache must be available from Step 1
         performReadAndLoad();
 
+        EXPECT_GT(m_plugin->m_getMetricCalled, 0); // verify: 'getMetric was called'
+        EXPECT_EQ(m_plugin->m_loadNetworkCalled, 0); // verify: 'load was not called' (optimization works)
+        EXPECT_EQ(m_plugin->m_exportCalled, 0); // verify: 'export was not called' (optimization works)
+        EXPECT_EQ(m_plugin->m_importNetworkCalled, 1); // verify: 'import was called instead of load + export'
+    }
+}
+
+TEST_F(CachingTest, TestLoadByName) {
+    enableCacheConfig();
+    auto performLoadByName = [&] {
+        auto exeNet = ie.LoadNetwork(modelName, deviceName);
+        (void)exeNet;
+    };
+
+    { // Step 1: read and load network without cache
+        performLoadByName();
+
+        EXPECT_GT(m_plugin->m_getMetricCalled, 0); // verify: 'getMetric was called'
+        EXPECT_EQ(m_plugin->m_loadNetworkCalled, 1); // verify: 'load was called'
+        EXPECT_EQ(m_plugin->m_exportCalled, 1); // verify: 'export was called'
+        EXPECT_EQ(m_plugin->m_importNetworkCalled, 0); // verify: 'import was not called'
+    }
+
+    m_plugin->resetCounters();
+
+    { // Step 2: same load, but now cache must be available from Step 1
+        performLoadByName();
+
+        EXPECT_GT(m_plugin->m_getMetricCalled, 0); // verify: 'getMetric was called'
         EXPECT_EQ(m_plugin->m_loadNetworkCalled, 0); // verify: 'load was not called' (optimization works)
         EXPECT_EQ(m_plugin->m_exportCalled, 0); // verify: 'export was not called' (optimization works)
-        EXPECT_GT(m_plugin->m_importNetworkCalled, 0); // verify: 'import was called instead of load + export'
+        EXPECT_EQ(m_plugin->m_importNetworkCalled, 1); // verify: 'import was called instead of load + export'
+    }
+}
+
+TEST_F(CachingTest, TestLoadByName_NoCacheSupported1) {
+    enableCacheConfig();                     // Enable caching in global settings
+    m_plugin->m_supportImportExport = false; // but it is not supported by plugin
+
+    auto performLoadByName = [&] {
+        auto exeNet = ie.LoadNetwork(modelName, deviceName);
+        (void)exeNet;
+    };
+
+    { // read and load network without cache
+        performLoadByName();
+
+        EXPECT_GT(m_plugin->m_getMetricCalled, 0); // verify: 'getMetric was called'
+        EXPECT_EQ(m_plugin->m_loadNetworkCalled, 1); // verify: 'load was called'
+        EXPECT_EQ(m_plugin->m_exportCalled, 0); // verify: 'export was not called'
+        EXPECT_EQ(m_plugin->m_importNetworkCalled, 0); // verify: 'import was not called'
     }
 }
 
+TEST_F(CachingTest, TestLoadByName_NoCacheEnabled) {
+    auto performLoadByName = [&] {
+        auto exeNet = ie.LoadNetwork(modelName, deviceName);
+        (void)exeNet;
+    };
+
+    { // read and load network without cache
+        performLoadByName();
+
+        EXPECT_EQ(m_plugin->m_getMetricCalled, 0); // verify: 'getMetric was not called when global cache is disabled'
+        EXPECT_EQ(m_plugin->m_loadNetworkCalled, 1); // verify: 'load was called'
+        EXPECT_EQ(m_plugin->m_exportCalled, 0); // verify: 'export was not called'
+        EXPECT_EQ(m_plugin->m_importNetworkCalled, 0); // verify: 'import was not called'
+    }
+}