Add multithreading support but it seems slower. It has been disable.

3 files changed, 75 insertions, 4 deletions

diff --git a/main.cpp b/main.cpp
index 46648a3..9dbf847 100644
--- a/main.cpp
+++ b/main.cpp
@@ -35,7 +35,7 @@ int main(int argc, char *argv[])
 
     QStringList commands;
 
-    commands<< "100D10/100"
+    commands<< "1000D10"
             << "2*(4+4)"
             << "1+(4*3)D10"
              << "2+4/4"
diff --git a/node/dicerollernode.cpp b/node/dicerollernode.cpp
index 735aacb..27750df 100644
--- a/node/dicerollernode.cpp
+++ b/node/dicerollernode.cpp
@@ -2,13 +2,40 @@
 #include "die.h"
 
 
-
+#include <QThread>
+#include <QThreadPool>
 #include <QDebug>
+#include <QTime>
+
+
+DiceRoller::DiceRoller(QMutex* mutex,DiceResult* diceResult,int faces,int count)
+    : m_mutex(mutex),m_sharedDiceResult(diceResult),m_faces(faces),m_diceCount(count)
+{
+
+}
+
+void DiceRoller::run()
+{
+    for(quint64 i=0; i < m_diceCount ; ++i)
+    {
+        Die* die = new Die();
+        die->setFaces(m_faces);
+        die->roll();
+        m_mutex->lock();
+        m_sharedDiceResult->insertResult(die);
+        m_mutex->unlock();
+    }
+}
+
+
 
+//////////////////////////////////////////////////
+/// \brief DiceRollerNode::DiceRollerNode
+//////////////////////////////////////////////////
 DiceRollerNode::DiceRollerNode(quint64 faces)
     : m_faces(faces),m_myDiceResult(new DiceResult())
 {
-
+    m_mutex=new QMutex();
     m_result=m_myDiceResult;
 
 }
@@ -30,12 +57,40 @@ void DiceRollerNode::run(ExecutionNode* previous)
                 die->roll();
                 m_myDiceResult->insertResult(die);
             }
+
+           /* quint64 threadCount = QThread::idealThreadCount();
+            if(threadCount>m_diceCount)
+            {
+                threadCount=m_diceCount;
+            }
+            quint64 dicePass = m_diceCount/threadCount;
+            quint64 remainingDiceCount=m_diceCount;
+
+            QThreadPool threadpool;
+
+
+            for(int i=threadCount-1;i>=0 && remainingDiceCount>0;--i)
+            {
+                remainingDiceCount-=dicePass;
+                if((remainingDiceCount<dicePass)||((i==0)&&(remainingDiceCount!=0)))
+                {
+                    dicePass+=remainingDiceCount;
+                    remainingDiceCount=0;
+                }
+                qDebug() << remainingDiceCount << dicePass << i << threadCount;
+                threadpool.start(new DiceRoller(m_mutex,m_myDiceResult,m_faces,dicePass));
+            }
+
+            threadpool.waitForDone();*/
             if(NULL!=m_nextNode)
             {
                 m_nextNode->run(this);
             }
         }
     }
+
+
+
 }
 
 quint64 DiceRollerNode::getFaces()
diff --git a/node/dicerollernode.h b/node/dicerollernode.h
index b08901e..d46f8ba 100644
--- a/node/dicerollernode.h
+++ b/node/dicerollernode.h
@@ -2,10 +2,26 @@
 #define DICEROLLERNODE_H
 
 #include <Qt>
+#include <QRunnable>
+#include <QMutex>
 
 #include "executionnode.h"
 #include "diceresult.h"
+class DiceRoller : public QRunnable
+{
+public:
+    DiceRoller(QMutex* mutex,DiceResult* diceResult,int faces,int count);
+    virtual void run ();
+private:
+    QMutex* m_mutex;
+    DiceResult* m_sharedDiceResult;
+    int m_faces;
+    int m_diceCount;
+};
 
+/**
+ * @brief The DiceRollerNode class
+ */
 class DiceRollerNode : public ExecutionNode
 {
 public:
@@ -21,7 +37,7 @@ private:
     quint64 m_diceCount;
     quint64 m_faces; /// faces
     DiceResult* m_myDiceResult;
-
+    QMutex* m_mutex;
 };
 
 #endif // DICEROLLERNODE_H