Multithreaded load on Desc files (indev)

@@ -52,7 +52,8 @@
         "optional": "cpp",
         "optional": "cpp",
         "string_view": "cpp",
         "string_view": "cpp",
         "cstdarg": "cpp",
         "cstdarg": "cpp",
-        "iomanip": "cpp"
+        "iomanip": "cpp",
+        "string": "cpp"
     },
     },
     "python.pythonPath": "/usr/bin/python3",
     "python.pythonPath": "/usr/bin/python3",
     "editor.formatOnSave": true,
     "editor.formatOnSave": true,

 #ifndef MOTIF_H_
 #ifndef MOTIF_H_
 #define MOTIF_H_
 #define MOTIF_H_
 
 
+#include <mutex>
 #include <string>
 #include <string>
 #include <vector>
 #include <vector>
 
 
@@ -8,6 +9,16 @@ using std::pair;
 using std::string;
 using std::string;
 using std::vector;
 using std::vector;
 
 
+class Motif;    // forward declaration
+
+typedef struct args_ {
+    const string&  descfile;
+    string         rna;
+    vector<Motif>& final_results;
+    std::mutex&    posInsertionSites_mutex;
+    args_(const string& descfile_, string rna_, vector<Motif>& vector_, std::mutex& mutex_) : descfile(descfile_), rna(rna_), final_results(vector_), posInsertionSites_mutex(mutex_){}
+} args_of_parallel_func;
+
 typedef struct Comp_ {
 typedef struct Comp_ {
     pair<uint, uint> pos;
     pair<uint, uint> pos;
     size_t           k;
     size_t           k;
@@ -25,15 +36,15 @@ class Motif
     public:
     public:
     Motif();
     Motif();
     Motif(const vector<Component>& v, string PDB);
     Motif(const vector<Component>& v, string PDB);
-    void                 load_from_csv(string csv_line);
-    static vector<Motif> build_from_desc(const string& descfile, string rna);
-    static char          is_valid_DESC(const string& descfile);
-    string               pos_string(void) const;
-    string               get_origin(void) const;
-    string               get_identifier(void) const;
-    vector<Component>    comp;
-    double               score_;
-    bool                 reversed_;
+    void              load_from_csv(string csv_line);
+    static void       build_from_desc(args_of_parallel_func arg_struct);
+    static char       is_valid_DESC(const string& descfile);
+    string            pos_string(void) const;
+    string            get_origin(void) const;
+    string            get_identifier(void) const;
+    vector<Component> comp;
+    double            score_;
+    bool              reversed_;
 
 
     private:
     private:
     static vector<vector<Component>> find_next_ones_in(string rna, uint offset, vector<string> vc);
     static vector<vector<Component>> find_next_ones_in(string rna, uint offset, vector<string> vc);

+#include "Pool.h"
+
+Pool::Pool() : m_function_queue(), m_lock(), m_data_condition(), m_accept_functions(true)
+{
+}
+
+Pool::~Pool()
+{
+}
+
+void Pool::push(std::function<void()> func)
+{
+    std::unique_lock<std::mutex> lock(m_lock);
+    m_function_queue.push(func);
+    // when we send the notification immediately, the consumer will try to get the lock , so unlock asap
+    lock.unlock();
+    m_data_condition.notify_one();
+}
+
+void Pool::done()
+{
+    std::unique_lock<std::mutex> lock(m_lock);
+    m_accept_functions = false;
+    lock.unlock();
+    // when we send the notification immediately, the consumer will try to get the lock , so unlock asap
+    m_data_condition.notify_all();
+    //notify all waiting threads.
+}
+
+void Pool::infinite_loop_func()
+{
+    std::function<void()> func;
+    while (true)
+    {
+        {
+            std::unique_lock<std::mutex> lock(m_lock);
+            m_data_condition.wait(lock, [this]() {return !m_function_queue.empty() || !m_accept_functions; });
+            if (!m_accept_functions && m_function_queue.empty())
+            {
+                //lock will be release automatically.
+                //finish the thread loop and let it join in the main thread.
+                return;
+            }
+            func = m_function_queue.front();
+            m_function_queue.pop();
+            //release the lock
+        }
+        func();
+    }
+}
\ No newline at end of file

+#pragma once
+#include <atomic>
+#include <cassert>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <queue>
+
+class Pool
+{
+
+    private:
+    std::queue<std::function<void()>> m_function_queue;
+    std::mutex                        m_lock;
+    std::condition_variable           m_data_condition;
+    std::atomic<bool>                 m_accept_functions;
+
+    public:
+    Pool();
+    ~Pool();
+    std::mutex& get_mutex_reference(void);
+    void push(std::function<void()> func);
+    void done();
+    void infinite_loop_func();
+};
+
+inline std::mutex &Pool::get_mutex_reference(void) { return m_lock; }
+
+class quit_worker_exception : public std::exception {};
\ No newline at end of file

@@ -8,7 +8,6 @@
 #include <iostream>
 #include <iostream>
 #include <iterator>
 #include <iterator>
 #include <string>
 #include <string>
-#include <thread>
 #include <vector>
 #include <vector>
 
 
 #include "MOIP.h"
 #include "MOIP.h"