add: reading sorter data

Author: Casqade

include/SortingAlgorithmVisualizer/CommonTypes.hpp

@@ -20,6 +20,8 @@ struct RandomizeTask
 
   void* data {};
   size_t elementCount {};
+
+  std::mutex* dataMutex {};
 };
 
 

include/SortingAlgorithmVisualizer/Sorters/ISorter.hpp

@@ -2,6 +2,8 @@
 
 #include <SortingAlgorithmVisualizer/CommonTypes.hpp>
 
+#include <mutex>
+
 
 class ISorter
 {
@@ -12,9 +14,16 @@ class ISorter
   virtual bool step() = 0;
   virtual void reset() = 0;
 
+  bool tryReading();
+  void startReading();
+  void stopReading();
+
   RandomizeTask& getRandomizeTask();
 
 
 protected:
   RandomizeTask mRandomizeTask {};
+
+  std::mutex mDataMutex {};
+  std::unique_lock <std::mutex> mDataLock {mDataMutex, std::defer_lock};
 };

include/SortingAlgorithmVisualizer/Sorters/ISorterSpecialized.hpp

@@ -15,6 +15,7 @@ class ISorterSpecialized : public ISorter
     mRandomizeTask.callback = RandomizePlotData <T>;
     mRandomizeTask.data = mData->data();
     mRandomizeTask.elementCount = mData->size();
+    mRandomizeTask.dataMutex = &mDataMutex;
   }
 
 

include/SortingAlgorithmVisualizer/Sorters/MockSorter.hpp

@@ -2,6 +2,8 @@
 
 #include <SortingAlgorithmVisualizer/Sorters/ISorterSpecialized.hpp>
 
+#include <thread>
+
 
 template <typename T>
 class MockSorter : public ISorterSpecialized <T>
@@ -27,6 +29,17 @@ class MockSorter : public ISorterSpecialized <T>
     if ( this->mData == nullptr )
       return true;
 
-    return ++mCounter == this->mData->size();
+
+//    simulate sorting operation
+    const bool isSorted =
+      ++mCounter == this->mData->size();
+
+
+    std::lock_guard <std::mutex> lock (this->mDataMutex);
+
+//    simulate accumulated write operations
+    std::this_thread::sleep_for(std::chrono::milliseconds{1});
+
+    return isSorted;
   }
 };

src/ISorter.cpp

@@ -1,6 +1,24 @@
 #include <SortingAlgorithmVisualizer/Sorters/ISorter.hpp>
 
 
+bool
+ISorter::tryReading()
+{
+  return mDataLock.try_lock();
+}
+
+void
+ISorter::startReading()
+{
+  mDataLock.lock();
+}
+
+void
+ISorter::stopReading()
+{
+  mDataLock.unlock();
+}
+
 RandomizeTask&
 ISorter::getRandomizeTask()
 {

src/SortingAlgorithmVisualizer.cpp

@@ -2,7 +2,6 @@
 #include <SortingAlgorithmVisualizer/CommonTypes.hpp>
 #include <SortingAlgorithmVisualizer/Sorters/MockSorter.hpp>
 
-#include <vector>
 #include <thread>
 #include <condition_variable>
 
@@ -108,12 +107,14 @@ randomizerThreadProc(
 
     if ( task != nullptr )
     {
-      task->callback(task->data, task->elementCount);
+      {
+        std::lock_guard <std::mutex> lock (*task->dataMutex);
+        task->callback(task->data, task->elementCount);
+      }
 
       {
-        std::unique_lock <std::mutex> lock (task->taskFinishedMutex);
+        std::lock_guard <std::mutex> lock (task->taskFinishedMutex);
         task->callback = nullptr; // mark task as done
-        lock.unlock();
       }
 
       task->taskFinishedSignal.notify_one();
@@ -131,9 +132,6 @@ main()
 
   ThreadSharedData sharedState {};
 
-  std::vector <ThreadLocalData> threadData (
-    plotCount, {sharedState} );
-
   PlotData <int> testData {};
   testData.init(1000);
 
@@ -146,25 +144,48 @@ main()
     testData1[i] = i;
   }
 
-  threadData[0].sorter = new MockSorter <int> (testData);
-  threadData[1].sorter = new MockSorter <int> (testData1);
 
-  std::vector <std::thread> threads {};
-  threads.reserve(plotCount);
+  ThreadLocalData threadsData[plotCount]
+  {
+    {sharedState, new MockSorter <int> (testData)},
+    {sharedState, new MockSorter <int> (testData1)},
+  };
+
+  std::thread sorterThreads[plotCount] {};
+
+  for ( size_t i {}; i < plotCount; ++i )
+    sorterThreads[i] = std::thread{sorterThreadProc, &threadsData[i]};
 
-  threads.emplace_back(sorterThreadProc, &threadData[0]);
-  threads.emplace_back(sorterThreadProc, &threadData[1]);
 
   auto randomizerThread = std::thread(
     randomizerThreadProc, &sharedState );
 
 
+  for ( size_t frame {}; frame < 1000; ++frame )
+  {
+    for ( size_t i {}; i < plotCount; ++i )
+    {
+      if ( threadsData[i].sorter->tryReading() == true )
+      {
+//        simulate copying to back buffer
+        std::this_thread::sleep_for(std::chrono::milliseconds{5});
+
+        threadsData[i].sorter->stopReading();
+      }
+    }
+
+//    write to vertex buffer
+//    glVertexAttribDivisor + glDrawArraysInstanced
+//    swap
+  }
+
   std::this_thread::sleep_for(std::chrono::seconds{1});
 
+
   sharedState.shutdownRequested.store(
     true, std::memory_order_relaxed );
 
-  for ( auto&& thread : threads )
+  for ( auto&& thread : sorterThreads )
     thread.join();
 
   sharedState.sorterThreadsAreDead.store(
@@ -180,5 +201,8 @@ main()
 
   randomizerThread.join();
 
+  for ( auto&& threadData : threadsData )
+    delete threadData.sorter;
+
   return 0;
 }