[GPU] Make singleton OCL Context

Author: isanghao

docs/sphinx_setup/api/nodejs_api/openvino-node/interfaces/Core.rst

@@ -2,10 +2,9 @@ Interface Core
 ==============
 
 Core represents an OpenVINO runtime Core entity.
-User applications can create several Core class instances,
-but in this case, the underlying plugins
-are created multiple times and not shared between several Core instances.
-It is recommended to have a single Core instance per application.
+User applications can create several Core class instances.
+In that case the device plugins will still share
+underlying resources (such as OCL context) in per-device singleton.
 
 .. code-block:: ts
 

src/bindings/js/node/lib/addon.ts

@@ -28,10 +28,9 @@ export type OVAny = string | number | boolean;
 /**
  * Core represents an OpenVINO runtime Core entity.
  *
- * User applications can create several Core class instances,
- * but in this case, the underlying plugins
- * are created multiple times and not shared between several Core instances.
- * It is recommended to have a single Core instance per application.
+ * User applications can create several Core class instances.
+ * In that case the device plugins will still share underlying resources
+ * (such as OCL context) in per-device singleton.
  */
 export interface Core {
   /**

src/bindings/python/src/openvino/_ov_api.pyi

@@ -273,10 +273,9 @@ class Core(openvino._pyopenvino.Core):
     """
     Core class represents OpenVINO runtime Core entity.
     
-        User applications can create several Core class instances, but in this
-        case, the underlying plugins are created multiple times and not shared
-        between several Core instances. The recommended way is to have a single
-        Core instance per application.
+        User applications can create several Core class instances. In that case
+        the device plugins will still share underlying resources (such as OCL context)
+        in per-device singleton.
         
     """
     def compile_model(self, model: typing.Union[openvino._ov_api.Model, str, pathlib.Path], device_name: typing.Optional[str] = None, config: typing.Optional[dict[str, typing.Any]] = None, *, weights: typing.Optional[bytes] = None) -> CompiledModel:

src/bindings/python/src/pyopenvino/core/core.cpp

@@ -23,10 +23,9 @@ namespace py = pybind11;
 
 void regclass_Core(py::module m) {
     py::class_<ov::Core, std::shared_ptr<ov::Core>> cls(m, "Core");
-    cls.doc() =
-        "openvino.Core class represents OpenVINO runtime Core entity. User applications can create several "
-        "Core class instances, but in this case, the underlying plugins are created multiple times and not shared "
-        "between several Core instances. The recommended way is to have a single Core instance per application.";
+    cls.doc() = "openvino.Core class represents OpenVINO runtime Core entity. User applications can create several "
+                "Core class instances. In that case the device plugins will still share underlying "
+                "resources (such as OCL context) in per-device singleton.";
 
     cls.def(py::init([](const py::object& xml_config_file) {
                 return std::make_shared<ov::Core>(Common::utils::to_fs_path(xml_config_file));

src/inference/include/openvino/runtime/core.hpp

@@ -31,9 +31,8 @@ namespace ov {
 /**
  * @brief This class represents an OpenVINO runtime Core entity.
  * @ingroup ov_runtime_cpp_api
- * User applications can create several Core class instances, but in this case the underlying plugins
- * are created multiple times and not shared between several Core instances. The recommended way is to have
- * a single Core instance per application.
+ * User applications can create several Core class instances. In that case the device plugins
+ * will still share underlying resources (such as OCL context) in per-device singleton.
  */
 class OPENVINO_RUNTIME_API Core {
     class Impl;

src/plugins/intel_gpu/include/intel_gpu/plugin/plugin.hpp

@@ -20,9 +20,6 @@ class Plugin : public ov::IPlugin {
     std::map<std::string, ExecutionConfig> m_configs_map;
     ov::AnyMap m_compiled_model_runtime_properties;
 
-    mutable std::map<std::string, std::shared_ptr<RemoteContextImpl>> m_default_contexts;
-    mutable std::once_flag m_default_contexts_once;
-
     std::map<std::string, std::shared_ptr<RemoteContextImpl>> get_default_contexts() const;
 
     std::shared_ptr<ov::Model> clone_and_transform_model(const std::shared_ptr<const ov::Model>& network,

src/plugins/intel_gpu/src/plugin/plugin.cpp

@@ -201,6 +201,9 @@ std::shared_ptr<ov::Model> Plugin::clone_and_transform_model(const std::shared_p
 }
 
 std::map<std::string, RemoteContextImpl::Ptr> Plugin::get_default_contexts() const {
+    static std::map<std::string, std::shared_ptr<RemoteContextImpl>> m_default_contexts;
+    static std::once_flag m_default_contexts_once;
+
     std::call_once(m_default_contexts_once, [this]() {
         // Create default context
         for (auto& device : m_device_map) {

src/plugins/intel_gpu/tests/functional/behavior/infer_request.cpp

@@ -18,6 +18,8 @@
 #include "common_test_utils/subgraph_builders/read_concat_split_assign.hpp"
 #include "openvino/op/add.hpp"
 #include "openvino/op/unsqueeze.hpp"
+#include "openvino/runtime/intel_gpu/ocl/ocl.hpp"
+#include "openvino/runtime/intel_gpu/ocl/ocl_wrapper.hpp"
 
 namespace {
 typedef std::tuple<
@@ -393,4 +395,15 @@ TEST(TensorTest, smoke_canShareTensorIfModelsFromDifferentCores) {
     OV_ASSERT_NO_THROW(request1.infer());
     OV_ASSERT_NO_THROW(request2.infer());
 }
+
+TEST(CoreTest, smoke_singletonOclContext) {
+    auto core1 = ov::Core();
+    auto ctx1 = core1.get_default_context("GPU");
+    auto& oclContext1 = static_cast<ov::intel_gpu::ocl::ClContext&>(ctx1);
+    auto core2 = ov::Core();
+    auto ctx2 = core2.get_default_context("GPU");
+    auto& oclContext2 = static_cast<ov::intel_gpu::ocl::ClContext&>(ctx2);
+    ASSERT_EQ(oclContext1.get(), oclContext2.get());
+}
+
 } // namespace