create shared_data_access class

Author: Noy-Zini

common/graph-model.cpp

@@ -7,7 +7,7 @@ using namespace rs2;
 
 void graph_model::process_frame(rs2::frame f)
 {
-    shared_data_access::write_shared_data(
+    shared_data.write(
         [&]()
         {
             if (!_paused && f && f.is< rs2::motion_frame >()
@@ -42,7 +42,7 @@ void graph_model::process_frame(rs2::frame f)
 
                 }
             }
-        }, _m);
+        });
 }
 
 void graph_model::draw(rect stream_rect)
@@ -56,13 +56,13 @@ void graph_model::draw(rect stream_rect)
         time_index[i] = static_cast<float>(i);
 
     // Read shared history data
-    auto x_hist = shared_data_access::read_shared_data<std::vector<float>>([&]() { return _x_history; }, _m);
-    auto y_hist = shared_data_access::read_shared_data<std::vector<float>>([&]() { return _y_history; }, _m);
-    auto z_hist = shared_data_access::read_shared_data<std::vector<float>>([&]() { return _z_history; }, _m);
+    auto x_hist = shared_data.read<std::vector<float>>([&]() { return _x_history; });
+    auto y_hist = shared_data.read<std::vector<float>>([&]() { return _y_history; });
+    auto z_hist = shared_data.read<std::vector<float>>([&]() { return _z_history; });
 
     std::vector<float> n_hist;
     if(_show_n_value) 
-        n_hist = shared_data_access::read_shared_data<std::vector<float>>([&]() { return _n_history; }, _m);
+        n_hist = shared_data.read<std::vector<float>>([&]() { return _n_history; });
 
     ImGui::BeginChild(_name.c_str(), ImVec2(stream_rect.w + 2, stream_rect.h));
 
@@ -83,7 +83,7 @@ void graph_model::draw(rect stream_rect)
 
 void graph_model::clear()
 {
-    shared_data_access::write_shared_data(
+    shared_data.write(
         [&]()
         {
             _x_history.clear();
@@ -99,7 +99,7 @@ void graph_model::clear()
                 if(_show_n_value)
                     _n_history.push_back(0);
             }
-        }, _m);
+        });
 }
 
 void graph_model::pause()

common/graph-model.h

@@ -7,9 +7,11 @@
 #include <implot.h> 
 #include <mutex>
 #include <vector>
+#include <GLFW/glfw3.h>
 #include <rsutils/time/periodic-timer.h>
-
-#include "output-model.h"
+#include "rect.h"
+#include <librealsense2/rs.hpp>
+#include <rsutils/concurrency/shared-data-access.h>
 
 namespace rs2
 {
@@ -20,7 +22,8 @@ namespace rs2
             : _name(name),
             _stream_type(stream),
             _show_n_value(show_n_value),
-            _update_timer{ std::chrono::milliseconds(_update_rate) }
+            _update_timer{ std::chrono::milliseconds(_update_rate) },
+            shared_data(_m)
         {
             clear();
         }
@@ -42,6 +45,7 @@ namespace rs2
         const int VECTOR_SIZE = 300;
         std::vector< float > _x_history, _y_history, _z_history, _n_history;
 
+        rsutils::concurrency::shared_data_access shared_data;
         std::mutex _m;
         std::string _name;
 

common/output-model.cpp

@@ -1204,7 +1204,7 @@ void stream_dashboard::draw_dashboard(ux_window& win, rect& r)
 
 void frame_drops_dashboard::process_frame(rs2::frame f)
 {
-    shared_data_access::write_shared_data([&](){
+    shared_data.write([&](){
         double ts = glfwGetTime();
         if (method == 1) ts = f.get_timestamp() / 1000.f;
         auto it = stream_to_time.find(f.get_profile().unique_id());
@@ -1236,12 +1236,12 @@ void frame_drops_dashboard::process_frame(rs2::frame f)
         }
 
         stream_to_time[f.get_profile().unique_id()] = ts;
-    }, m );
+    });
 }
 
 void frame_drops_dashboard::draw(ux_window& win, rect r)
 {
-    auto hist = shared_data_access::read_shared_data<std::deque<int>>([&](){ return drops_history; }, m);
+    auto hist = shared_data.read<std::deque<int>>([&](){ return drops_history; });
     for (int i = 0; i < hist.size(); i++)
     {
         add_point((float)i, (float)hist[i]);
@@ -1277,7 +1277,7 @@ int frame_drops_dashboard::get_height() const
 
 void frame_drops_dashboard::clear(bool full)
 {
-    shared_data_access::write_shared_data([&](){
+    shared_data.write([&](){
         stream_to_time.clear();
         last_time = 0;
         *total = 0;
@@ -1288,5 +1288,5 @@ void frame_drops_dashboard::clear(bool full)
             for (int i = 0; i < 100; i++)
                 drops_history.push_back(0);
         }
-    }, m);
+    });
 }

common/output-model.h

@@ -18,35 +18,17 @@
 #include <imgui.h>
 
 #include <rsutils/concurrency/concurrency.h>
+#include <rsutils/concurrency/shared-data-access.h>
 
 namespace rs2
 {
     class device_model;
     class ux_window;
 
-    class shared_data_access
-    {
-    public:
-        shared_data_access() = delete;
-
-        static void write_shared_data( const std::function< void() > & action, std::mutex & m )
-        {
-            std::lock_guard< std::mutex > lock( m );
-            action();
-        }
-
-        template< class T >
-        static T read_shared_data( const std::function< T() > & action, std::mutex & m )
-        {
-            std::lock_guard< std::mutex > lock( m );
-            return action();
-        }
-    };
-
     class stream_dashboard
     {
     public:
-        stream_dashboard(std::string name, int size) : q(size), name(name), t([this](){ thread_function(); }) {}
+        stream_dashboard(std::string name, int size) : q(size), name(name), shared_data(m), t([this](){ thread_function(); }) {}
         virtual ~stream_dashboard()
         {
             stop = true;
@@ -73,7 +55,8 @@ namespace rs2
 
         void draw_dashboard(ux_window& win, rect& r);
 
-        std::mutex m;
+        rsutils::concurrency::shared_data_access shared_data;
+
     private:
         void thread_function()
         {
@@ -86,6 +69,7 @@ namespace rs2
         }
         std::string name;
         rs2::frame_queue q;
+        std::mutex m;
         std::atomic<int> stop { false };
         std::thread t;
         std::vector<std::pair<float, float>> xy;

third-party/rsutils/include/rsutils/concurrency/shared-data-access.h

@@ -0,0 +1,34 @@
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2025 Intel Corporation. All Rights Reserved.
+#pragma once
+#include <mutex>
+
+namespace rsutils {
+    namespace concurrency {
+
+        class shared_data_access
+        {
+        public:
+            shared_data_access(std::mutex& mutex_ref)
+                : m_mutex(mutex_ref) {
+            }
+
+            void write(const std::function<void()>& action)
+            {
+                std::lock_guard<std::mutex> lock(m_mutex);
+                action();
+            }
+
+            template<class T>
+            T read(const std::function<T()>& action) const
+            {
+                std::lock_guard<std::mutex> lock(m_mutex);
+                return action();
+            }
+
+        private:
+            std::mutex& m_mutex;
+        };
+
+    }
+}