Fix NPU segfault with two concurrent inference pipelines

When two gvadetect pipelines target device=NPU simultaneously the NPU
VCL compiler crashes with "ConvertVPUMI37XX2ELF failed: bad optional
access" followed by SIGSEGV.

Root causes and fixes:

1. ov::Core::compile_model() is not re-entrant for the NPU plugin.
   The existing Meyers-singleton ov::Core is thread-safe to construct
   but concurrent compile_model calls race inside the NPU driver.
   Added a compile_mutex that serializes only compile_model and
   remote-context creation — read_model is intentionally left
   unserialized since it is a pure XML parse with no device contact.

2. gvafpscounter accesses its global fps_counters map without holding
   channels_mutex in create_average, create_writepipe, create_readpipe,
   new_frame and eos.  Added the missing lock_guard in each.

3. NPU does not support batch-size > 1.  Requesting batch-size=32
   triggers a compiler crash even on a single pipeline.  Added a clamp
   to 1 with a warning when device contains "NPU".

Tested: 5/5 concurrent dual-pipeline runs pass (0/5 before fix).
Single pipeline: 90 FPS, no regression.  Dual pipeline: 44 FPS each.

Author: oonyshch

src/gst/elements/gvafpscounter/fpscounter_c.cpp

@@ -41,10 +41,10 @@ void fps_counter_create_iterative(const char *intervals, bool print_std_dev, boo
 
 void fps_counter_create_average(unsigned int starting_frame, unsigned int interval) {
     try {
+        std::lock_guard<std::mutex> lock(channels_mutex);
         if (not fps_counters.count("average")) {
-            std::shared_ptr<FpsCounter> fps_counter = nullptr;
-            fps_counter = std::make_shared<IterativeFpsCounter>(starting_frame, interval, true, false, false);
-            fps_counters.insert({"average", fps_counter});
+            fps_counters.insert({"average",
+                std::make_shared<IterativeFpsCounter>(starting_frame, interval, true, false, false)});
         }
     } catch (std::exception &e) {
         GVA_ERROR("Error during creation average fpscounter: %s", Utils::createNestedErrorMsg(e).c_str());
@@ -53,10 +53,9 @@ void fps_counter_create_average(unsigned int starting_frame, unsigned int interv
 
 void fps_counter_create_writepipe(const char *pipe_name) {
     try {
+        std::lock_guard<std::mutex> lock(channels_mutex);
         if (not fps_counters.count("writepipe")) {
-            std::shared_ptr<FpsCounter> fps_counter = nullptr;
-            fps_counter = std::make_shared<WritePipeFpsCounter>(pipe_name);
-            fps_counters.insert({"writepipe", fps_counter});
+            fps_counters.insert({"writepipe", std::make_shared<WritePipeFpsCounter>(pipe_name)});
         }
     } catch (std::exception &e) {
         GVA_ERROR("Error during creation writepipe fpscounter: %s", Utils::createNestedErrorMsg(e).c_str());
@@ -65,18 +64,17 @@ void fps_counter_create_writepipe(const char *pipe_name) {
 
 void fps_counter_create_readpipe(void *fpscounter, const char *pipe_name) {
     try {
+        std::lock_guard<std::mutex> lock(channels_mutex);
         if (not fps_counters.count("readpipe")) {
             auto pipe_complete_lambda = [=]() {
                 fps_counter_eos(GST_ELEMENT_NAME(GST_BASE_TRANSFORM(fpscounter)));
-                // Pushing an EOS event downstream to signal that we're done.
                 bool handled = gst_pad_push_event(GST_BASE_TRANSFORM(fpscounter)->srcpad, gst_event_new_eos());
                 if (!handled)
                     throw std::runtime_error("FpsCounter ReadPipe: EOS event wasn't handled. Spinning...");
             };
             auto new_message_lambda = [](const char *name) { fps_counter_new_frame(NULL, name, NULL); };
-            std::shared_ptr<FpsCounter> fps_counter = nullptr;
-            fps_counter = std::make_shared<ReadPipeFpsCounter>(pipe_name, new_message_lambda, pipe_complete_lambda);
-            fps_counters.insert({"readpipe", fps_counter});
+            fps_counters.insert({"readpipe",
+                std::make_shared<ReadPipeFpsCounter>(pipe_name, new_message_lambda, pipe_complete_lambda)});
         }
     } catch (std::exception &e) {
         GVA_ERROR("Error during creation readpipe fpscounter: %s", Utils::createNestedErrorMsg(e).c_str());
@@ -85,6 +83,7 @@ void fps_counter_create_readpipe(void *fpscounter, const char *pipe_name) {
 
 void fps_counter_new_frame(GstBuffer *buffer, const char *element_name, void *gstgvafpscounter) {
     try {
+        std::lock_guard<std::mutex> lock(channels_mutex);
         for (auto counter = fps_counters.begin(); counter != fps_counters.end(); ++counter) {
             counter->second->NewFrame(element_name, output, buffer);
             if (gstgvafpscounter && counter->first == "average") {
@@ -102,6 +101,7 @@ void fps_counter_new_frame(GstBuffer *buffer, const char *element_name, void *gs
 
 void fps_counter_eos(const char *element_name) {
     try {
+        std::lock_guard<std::mutex> lock(channels_mutex);
         for (auto counter = fps_counters.begin(); counter != fps_counters.end(); ++counter)
             counter->second->EOS(element_name, output);
     } catch (std::exception &e) {

src/monolithic/inference_backend/image_inference/openvino/openvino_image_inference.cpp

@@ -42,6 +42,7 @@
 
 #include <functional>
 #include <iterator>
+#include <mutex>
 #include <regex>
 #include <stdio.h>
 #include <thread>
@@ -754,12 +755,18 @@ class OpenVinoNewApiImpl {
         return 0;
     }
 
-    // Singleton core object
     static ov::Core &core() {
         static ov::Core ovcore;
         return ovcore;
     }
 
+    // Serializes compile_model / create_context calls that trigger device plugin init.
+    // read_model is intentionally NOT serialized — it is a pure XML parse.
+    static std::mutex &compile_mutex() {
+        static std::mutex m;
+        return m;
+    }
+
   protected:
     std::shared_ptr<ov::Model> _model;
     std::string _model_path;
@@ -809,10 +816,15 @@ class OpenVinoNewApiImpl {
             try {
                 _batch_size = core().get_property(config.device(), ov::optimal_batch_size);
             } catch (...) {
-                _batch_size = 1; // Fallback if optimal batch size property is not supported
+                _batch_size = 1;
             }
         }
 
+        if (_device.find("NPU") != std::string::npos && _batch_size > 1) {
+            GVA_WARNING("NPU does not support batch-size > 1, clamping from %d to 1", _batch_size);
+            _batch_size = 1;
+        }
+
         _batch_timeout = config.batch_timeout();
 
         if (_batch_timeout > -1) {
@@ -1071,14 +1083,17 @@ class OpenVinoNewApiImpl {
         }
 
         // print_input_and_outputs_info(*_model);
-        if (_openvino_context) {
-            _compiled_model = core().compile_model(_model, _openvino_context->remote_context(), ov_params);
-        } else {
-            std::string formatted_device = _device;
-            if (_batch_timeout > -1) {
-                formatted_device = fmt::format("BATCH:{}({})", _device, _auto_batch_num_requests);
+        {
+            std::lock_guard<std::mutex> lock(compile_mutex());
+            if (_openvino_context) {
+                _compiled_model = core().compile_model(_model, _openvino_context->remote_context(), ov_params);
+            } else {
+                std::string formatted_device = _device;
+                if (_batch_timeout > -1) {
+                    formatted_device = fmt::format("BATCH:{}({})", _device, _auto_batch_num_requests);
+                }
+                _compiled_model = core().compile_model(_model, formatted_device, ov_params);
             }
-            _compiled_model = core().compile_model(_model, formatted_device, ov_params);
         }
         GVA_INFO("Network loaded to device");
 
@@ -1129,6 +1144,7 @@ class OpenVinoNewApiImpl {
                 if (_app_context) {
                     try {
                         dlstreamer::D3D11ContextPtr d3d11_ctx = dlstreamer::D3D11Context::create(_app_context);
+                        std::lock_guard<std::mutex> lock(compile_mutex());
                         _openvino_context = std::make_shared<dlstreamer::OpenVINOContext>(core(), _device, d3d11_ctx);
                     } catch (std::exception &e) {
                         GVA_ERROR("Exception occurred when creating OpenVINO™ toolkit remote context: %s", e.what());
@@ -1144,6 +1160,7 @@ class OpenVinoNewApiImpl {
                 if (_app_context) {
                     try {
                         dlstreamer::VAAPIContextPtr vaapi_ctx = dlstreamer::VAAPIContext::create(_app_context);
+                        std::lock_guard<std::mutex> lock(compile_mutex());
                         _openvino_context = std::make_shared<dlstreamer::OpenVINOContext>(core(), _device, vaapi_ctx);
                     } catch (std::exception &e) {
                         GVA_ERROR("Exception occurred when creating OpenVINO™ toolkit remote context: %s", e.what());