Replaced boost threads and mutexes with std threads and mutexes (c++11)

Core/Algorithms/src/GISASSimulation.cpp

@@ -26,11 +26,6 @@
 #include "Histogram2D.h"
 
 #include "Macros.h"
-GCC_DIAG_OFF(unused-parameter)
-GCC_DIAG_OFF(strict-aliasing)
-#include <boost/thread.hpp>
-GCC_DIAG_ON(strict-aliasing)
-GCC_DIAG_ON(unused-parameter)
 #include <gsl/gsl_errno.h>
 #include <boost/scoped_ptr.hpp>
 

Core/Algorithms/src/ProgressHandler.cpp

@@ -18,7 +18,7 @@
 #include "Simulation.h"
 #include "MultiLayer.h"
 #include "LayerInterface.h"
-#include <boost/thread.hpp>
+#include <mutex>
 
 
 ProgressHandler::ProgressHandler()
@@ -44,8 +44,8 @@ void ProgressHandler::reset()
 //! them to stop calculations.
 bool ProgressHandler::update(int n)
 {
-    static boost::mutex single_mutex;
-    boost::unique_lock<boost::mutex> single_lock( single_mutex );
+    static std::mutex single_mutex;
+    std::unique_lock<std::mutex> single_lock( single_mutex );
 
     // this flag is to inform Simulation that GUI wants it to be terminated
     bool continue_calculations(true);

Core/Algorithms/src/Simulation.cpp

@@ -23,11 +23,9 @@
 #include "BornAgainNamespace.h"
 #include "ProgressHandlerDWBA.h"
 #include "OMPISimulation.h"
+#include <thread>
 
 #include "Macros.h"
-GCC_DIAG_OFF(strict-aliasing);
-#include <boost/thread.hpp>
-GCC_DIAG_ON(strict-aliasing);
 #include <gsl/gsl_errno.h>
 #include <boost/scoped_ptr.hpp>
 
@@ -231,7 +229,7 @@ void Simulation::runSingleSimulation()
         // Multithreading.
         if (m_thread_info.n_threads == 0) {
             // Take optimal number of threads from the hardware.
-            m_thread_info.n_threads = (int)boost::thread::hardware_concurrency();
+            m_thread_info.n_threads = (int)std::thread::hardware_concurrency();
             msglog(MSG::DEBUG) << "Simulation::runSimulation() -> Info. Number of threads "
                                << m_thread_info.n_threads << " (taken from hardware concurrency)"
                                << ", n_batches = " << m_thread_info.n_batches
@@ -242,7 +240,7 @@ void Simulation::runSingleSimulation()
                                << ", n_batches = " << m_thread_info.n_batches
                                << ", current_batch = " << m_thread_info.current_batch;
         }
-        std::vector<boost::thread *> threads;
+        std::vector<std::thread *> threads;
         std::vector<DWBASimulation *> simulations;
 
         // Initialize n simulations.
@@ -269,7 +267,7 @@ void Simulation::runSingleSimulation()
         // Run simulations in n threads.
         for (std::vector<DWBASimulation *>::iterator it = simulations.begin();
              it != simulations.end(); ++it) {
-            threads.push_back(new boost::thread(boost::bind(&DWBASimulation::run, *it)));
+            threads.push_back(new std::thread(boost::bind(&DWBASimulation::run, *it)));
         }
 
         // Wait for threads to complete.

Core/Tools/inc/ISingleton.h

@@ -19,12 +19,8 @@
 #include <stdexcept>
 #include <iostream>
 #include <typeinfo>
+#include <mutex>
 #include "Macros.h"
-GCC_DIAG_OFF(unused-parameter)
-GCC_DIAG_OFF(strict-aliasing)
-#include <boost/thread.hpp>
-GCC_DIAG_ON(strict-aliasing)
-GCC_DIAG_ON(unused-parameter)
 
 //! @class ISingleton
 //! @ingroup tools_internal
@@ -36,8 +32,8 @@ class ISingleton
 public:
     static T& instance()
     {
-        static boost::mutex single_mutex;
-        boost::unique_lock<boost::mutex> single_lock( single_mutex );
+        static std::mutex single_mutex;
+        std::unique_lock<std::mutex> single_lock( single_mutex );
         if( !m_instance) {
             if( m_destroyed ) {
                 onDeadReference();

Core/Tools/src/Utils.cpp

@@ -24,13 +24,9 @@
 #include <boost/date_time/local_time_adjustor.hpp>
 #include <boost/date_time/c_local_time_adjustor.hpp>
 #include <string>
+#include <thread>
 
 #include "Macros.h"
-GCC_DIAG_OFF(unused-parameter)
-GCC_DIAG_OFF(strict-aliasing)
-#include <boost/thread.hpp>
-GCC_DIAG_ON(strict-aliasing)
-GCC_DIAG_ON(unused-parameter)
 
 
 #ifdef DEBUG_FPE
@@ -144,7 +140,7 @@ std::string Utils::String::getScientificDoubleString(double value, size_t precis
 
 int Utils::System::getThreadHardwareConcurrency()
 {
-    return (int)boost::thread::hardware_concurrency();
+    return std::thread::hardware_concurrency();
 }
 
 std::string Utils::System::getCurrentDateAndTime()