Merge branch 'master' into pruthvi/memory_allocator

src/ngraph/runtime/cpu/cpu_backend.cpp

@@ -109,18 +109,24 @@ shared_ptr<runtime::Executable>
 #endif
 
     shared_ptr<runtime::Executable> rc;
-    auto it = m_exec_map.find(func);
-    if (it != m_exec_map.end())
+    // we will protect the access to map (m_exec_map) across multiple threads by creating a lock_gaurd
+    // m_exec_map_mutex will be released once the object `guard` goes out of scope
     {
-        rc = it->second;
+        std::lock_guard<std::mutex> guard(m_exec_map_mutex);
+        auto it = m_exec_map.find(func);
+        if (it != m_exec_map.end())
+        {
+            rc = it->second;
+            return rc;
+        }
     }
-    else
+    rc = make_shared<CPU_Executable>(
+        func, pass_config, get_host_memory_allocator(), performance_counters_enabled);
     {
-        rc = make_shared<CPU_Executable>(
-            func, pass_config, get_host_memory_allocator(), performance_counters_enabled);
+        std::lock_guard<std::mutex> guard(m_exec_map_mutex);
         m_exec_map.insert({func, rc});
+        return rc;
     }
-    return rc;
 }
 
 runtime::cpu::CPU_Executable::CPU_Executable(shared_ptr<Function> func,
@@ -164,6 +170,7 @@ bool runtime::cpu::CPU_Executable::call(const vector<shared_ptr<runtime::Tensor>
 
 void runtime::cpu::CPU_Backend::remove_compiled_function(shared_ptr<Executable> exec)
 {
+    std::lock_guard<std::mutex> guard(m_exec_map_mutex);
     for (auto it = m_exec_map.begin(); it != m_exec_map.end(); ++it)
     {
         if (it->second == exec)

src/ngraph/runtime/cpu/cpu_backend.hpp

@@ -18,6 +18,7 @@
 
 #include <map>
 #include <memory>
+#include <mutex>
 
 #include "cpu_backend_visibility.h"
 #include "ngraph/pass/pass_config.hpp"
@@ -70,6 +71,9 @@ namespace ngraph
                 bool is_supported_property(const Property prop) const override;
 
             private:
+                // this mutex will be used to protect the addition and deletion
+                // of function to m_exec_map across multiple threads
+                std::mutex m_exec_map_mutex;
                 std::unordered_map<std::shared_ptr<Function>, std::shared_ptr<Executable>>
                     m_exec_map;
                 std::unique_ptr<Allocator> m_allocator;